revbot.js 0.0.13 → 0.0.15-build-test

package/dist/chunk-XQEYCTYC.js

@@ -0,0 +1,2601 @@
+import {
+  EventManager
+} from "./chunk-XMS4UTPG.js";
+import {
+  Presence,
+  Status
+} from "./chunk-YXX4DJB3.js";
+import {
+  Channel
+} from "./chunk-J2RF7D67.js";
+import {
+  Emoji
+} from "./chunk-5RK7FEID.js";
+import {
+  Invite
+} from "./chunk-R2PF552K.js";
+import {
+  Mentions
+} from "./chunk-BQS6ZLNY.js";
+import {
+  Attachment
+} from "./chunk-VU3XNPDE.js";
+import {
+  Base
+} from "./chunk-YLSAAPO4.js";
+import {
+  BaseClient
+} from "./chunk-MLKHJGSQ.js";
+import {
+  ChannelPermissions,
+  DEFAULT_PERMISSION_DM,
+  FullPermissions
+} from "./chunk-7PA5MDKS.js";
+import {
+  Badges
+} from "./chunk-LY7OFI25.js";
+import {
+  cdnUrl,
+  wsUrl
+} from "./chunk-LUDTY3LL.js";
+import {
+  UUID
+} from "./chunk-CQ4AJZQD.js";
+import {
+  BaseManager
+} from "./chunk-3GLQHMWL.js";
+import {
+  __async,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-ICANLKGX.js";
+
+// src/struct/message.ts
+var Message = class extends Base {
+  /**
+   * Creates a new Message instance.
+   *
+   * @param {client} client - The client instance.
+   * @param {APIMessage} data - The raw data for the message from the API.
+   */
+  constructor(client3, data) {
+    super(client3);
+    /** The type of the message (e.g., TEXT, SYSTEM). */
+    this.type = "TEXT";
+    /** The content of the message. */
+    this.content = "";
+    /** The ID of the channel where the message was sent. */
+    this.channelId = "";
+    /** The ID of the user who authored the message. */
+    this.authorId = "";
+    /** An array of embeds included in the message. */
+    this.embeds = [];
+    /** An array of file attachments included in the message. */
+    this.attachments = [];
+    /** Mentions included in the message. */
+    this.mentions = new Mentions(this, []);
+    /** The timestamp of when the message was last edited, or `null` if not edited. */
+    this.editedTimestamp = null;
+    /** the reactions and count on a message */
+    this.reactions = /* @__PURE__ */ new Map();
+    this._patch(data);
+  }
+  /**
+   * Updates the message instance with new data from the API.
+   *
+   * @param {APIMessage} data - The raw data for the message from the API.
+   * @returns {this} The updated message instance.
+   * @protected
+   */
+  _patch(data) {
+    super._patch(data);
+    if (Array.isArray(data.embeds)) {
+      this.embeds = data.embeds;
+    }
+    if (Array.isArray(data.attachments)) {
+      this.attachments = data.attachments;
+    }
+    if (Array.isArray(data.mentions)) {
+      this.mentions = new Mentions(this, data.mentions);
+    }
+    if (data.author) {
+      this.authorId = data.author;
+    }
+    if (data.channel) {
+      this.channelId = data.channel;
+    }
+    if (typeof data.content === "string") {
+      this.content = data.content;
+    }
+    if (data.system) {
+      this.type = data.system.type.toUpperCase();
+    }
+    if (data.edited) {
+      this.editedTimestamp = Date.parse(data.edited);
+    }
+    return this;
+  }
+  /**
+   * Gets the creation date of the message.
+   *
+   * @returns {Date} The date when the message was created.
+   */
+  get createdAt() {
+    return UUID.timestampOf(this.id);
+  }
+  /**
+   * Gets the creation timestamp of the message in milliseconds.
+   *
+   * @returns {number} The timestamp of when the message was created.
+   */
+  get createdTimestamp() {
+    return this.createdAt.getTime();
+  }
+  /**
+   * Gets the date when the message was last edited.
+   *
+   * @returns {Date | null} The date of the last edit, or `null` if not edited.
+   */
+  get editedAt() {
+    return this.editedTimestamp ? new Date(this.editedTimestamp) : null;
+  }
+  /**
+   * Checks if the message is a system message.
+   *
+   * @returns {boolean} `true` if the message is a system message, otherwise `false`.
+   */
+  get system() {
+    return this.type !== "TEXT";
+  }
+  /**
+   * Retrieves the author of the message.
+   *
+   * @returns {User | null} The user who authored the message, or `null` if not found.
+   */
+  get author() {
+    var _a;
+    return (_a = this.client.users.cache.get(this.authorId)) != null ? _a : null;
+  }
+  /**
+   * Retrieves the channel where the message was sent.
+   *
+   * @returns {TextChannel | DMChannel | GroupChannel} The channel instance.
+   */
+  get channel() {
+    return this.client.channels.cache.get(this.channelId);
+  }
+  /**
+   * Retrieves the server ID associated with the message, if any.
+   *
+   * @returns {string | null} The server ID, or `null` if the message is not in a server.
+   */
+  get serverId() {
+    const channel = this.channel;
+    return channel.inServer() ? channel.serverId : null;
+  }
+  /**
+   * Retrieves the server associated with the message, if any.
+   *
+   * @returns {Server | null} The server instance, or `null` if not found.
+   */
+  get server() {
+    var _a;
+    return (_a = this.client.servers.cache.get(this.serverId)) != null ? _a : null;
+  }
+  /**
+   * Retrieves the server member who authored the message, if any.
+   *
+   * @returns {ServerMember | null} The server member instance, or `null` if not found.
+   */
+  get member() {
+    var _a, _b;
+    return (_b = (_a = this.server) == null ? void 0 : _a.members.cache.get(this.authorId)) != null ? _b : null;
+  }
+  /**
+   * Gets the URL of the message.
+   *
+   * @returns {string} The URL of the message.
+   */
+  get url() {
+    return `https://app.revolt.chat/${this.serverId ? `server/${this.serverId}` : ""}/channel/${this.channelId}/${this.id}`;
+  }
+  /**
+   * Acknowledges the message.
+   *
+   * @returns {Promise<void>} A promise that resolves when the message is acknowledged.
+   */
+  ack() {
+    return this.channel.messages.ack(this);
+  }
+  /**
+   * Deletes the message.
+   *
+   * @returns {Promise<void>} A promise that resolves when the message is deleted.
+   */
+  delete() {
+    return this.channel.messages.delete(this);
+  }
+  /**
+   * Replies to the message.
+   *
+   * @param {string} content - The content of the reply.
+   * @param {boolean} [mention=true] - Whether to mention the original message author.
+   * @returns {Promise<Message>} A promise that resolves with the sent reply message.
+   */
+  reply(content, mention = true) {
+    return this.channel.messages.send(__spreadProps(__spreadValues({}, typeof content === "object" ? content : { content }), {
+      replies: [{ id: this.id, mention }]
+    }));
+  }
+  /**
+   * Edits the message.
+   *
+   * @param {MessageEditOptions | string} options - The new content or edit options.
+   * @returns {Promise<void>} A promise that resolves when the message is edited.
+   */
+  edit(options) {
+    return this.channel.messages.edit(this, options);
+  }
+  /**
+   * Fetches the latest data for the message.
+   *
+   * @returns {Promise<Message>} A promise that resolves with the updated message instance.
+   */
+  fetch() {
+    return this.channel.messages.fetch(this.id);
+  }
+  /**
+   * Adds a reaction to the message.
+   *
+   * @param {string} emoji - The emoji to react with.
+   * @returns {Promise<void>} A promise that resolves when the reaction is added.
+   */
+  addReaction(emoji) {
+    return this.channel.messages.addReaction(this, emoji);
+  }
+  /**
+   * Removes a reaction from the message.
+   *
+   * @param {string} emoji - The emoji to remove the reaction for.
+   * @param {object} [options] - Options for removing the reaction.
+   * @param {string} [options.user_id] - The user ID to remove the reaction for. If not provided, removes the reaction for the current user.
+   * @param {boolean} [options.remove_all=false] - Whether to remove all of the specified reaction for the message.
+   * @returns {Promise<void>} A promise that resolves when the reaction is removed.
+   */
+  removeReaction(emoji, options) {
+    var _a, _b;
+    return this.channel.messages.removeReaction(
+      this,
+      emoji,
+      (_a = options == null ? void 0 : options.user_id) != null ? _a : void 0,
+      (_b = options == null ? void 0 : options.remove_all) != null ? _b : false
+    );
+  }
+  /**
+   * Removes all reactions from the message.
+   *
+   * @returns {Promise<void>} A promise that resolves when all reactions are removed.
+   */
+  removeAllReactions() {
+    return this.channel.messages.removeAllReactions(this);
+  }
+  /**
+   * Checks if the message is in a server.
+   *
+   * @returns {boolean} `true` if the message is in a server, otherwise `false`.
+   */
+  inServer() {
+    return this.channel.inServer();
+  }
+  /**
+   * Converts the message to a string representation.
+   *
+   * @returns {string} The content of the message.
+   */
+  toString() {
+    return this.content;
+  }
+};
+
+// src/managers/channelManager.ts
+var ChannelManager = class extends BaseManager {
+  constructor() {
+    super(...arguments);
+    this.holds = null;
+  }
+  _add(data) {
+    let channel;
+    switch (data.channel_type) {
+      case "TextChannel":
+        channel = new TextChannel2(this.client, data);
+        break;
+      case "VoiceChannel":
+        channel = new VoiceChannel(this.client, data);
+        break;
+      case "DirectMessage":
+        channel = new DMChannel2(this.client, data);
+        break;
+      case "Group":
+        channel = new GroupChannel2(this.client, data);
+        break;
+      case "SavedMessages":
+        channel = new NotesChannel(this.client, data);
+        if (this.client.user) this.client.user.notes = channel;
+        break;
+      default:
+        throw new Error(`Unknown Channel Type: ${data}`);
+    }
+    this.cache.set(channel.id, channel);
+    return channel;
+  }
+  _remove(id) {
+    var _a;
+    const channel = this.cache.get(id);
+    if (channel == null ? void 0 : channel.inServer()) {
+      (_a = channel.server) == null ? void 0 : _a.channels.cache.delete(id);
+    }
+    super._remove(id);
+  }
+  /**
+   * used to delete a channel
+   *
+   * @param channel The channel to delete
+   * @returns A promise that resolves when the channel is deleted
+   */
+  delete(channel) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(channel);
+      if (!id) {
+        throw new TypeError("INVALID_TYPE");
+      }
+      yield this.client.api.delete(`/channels/${id}`);
+    });
+  }
+  /**
+   * used to fetch a channel
+   *
+   * @param channel The channel to fetch
+   * @param force Whether to force fetch the channel using the api or return it form cache if able
+   * @returns A promise that resolves with the fetched channel
+   */
+  fetch(_0) {
+    return __async(this, arguments, function* (channel, { force = true } = {}) {
+      const id = this.resolveId(channel);
+      if (!id) {
+        throw new TypeError("INVALID_TYPE");
+      }
+      if (!force) {
+        const channel2 = this.cache.get(id);
+        if (channel2) return channel2;
+      }
+      const data = yield this.client.api.get(`/channels/${id}`);
+      return this._add(data);
+    });
+  }
+  /**
+   * resolves a channel from a string or a channel object
+   * @param channel The channel to resolve
+   * @returns the resolved channel or null if not found
+   */
+  resolve(channel) {
+    if (channel instanceof Channel) return channel;
+    return super.resolve(channel);
+  }
+  /**
+   * resolves a channel id from a string or a channel object
+   * @param channel The channel to resolve
+   * @returns the resolved channel id or null if not found
+   */
+  resolveId(channel) {
+    if (channel instanceof Channel) return channel.id;
+    return super.resolveId(channel);
+  }
+};
+
+// src/managers/serverManager.ts
+var ServerManager = class extends BaseManager {
+  constructor() {
+    super(...arguments);
+    this.holds = Server2;
+  }
+  _remove(id) {
+    var _a;
+    const server = this.cache.get(id);
+    for (const id2 of (_a = server == null ? void 0 : server.channels.cache.keys()) != null ? _a : []) {
+      this.client.channels._remove(id2);
+    }
+    return super._remove(id);
+  }
+  /**
+   * edits a server
+   * @param server The server to edit
+   * @param options The options to edit the server with
+   * @param options.name The name of the server
+   * @param options.description The description of the server
+   * @returns A promise that resolves when the server is edited
+   */
+  edit(server, options) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(server);
+      if (!id) throw new TypeError("INVALID_TYPE");
+      yield this.client.api.patch(`/servers/${id}`, { body: options });
+    });
+  }
+  /**
+   * leaves a server
+   * @param server the server to leave
+   */
+  delete(server) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(server);
+      if (!id) throw new TypeError("INVALID_TYPE");
+      yield this.client.api.delete(`/servers/${id}`);
+    });
+  }
+  fetch(_0) {
+    return __async(this, arguments, function* (server, { force = true } = {}) {
+      const id = this.resolveId(server);
+      if (!id) throw new TypeError("INVALID_TYPE");
+      if (!force) {
+        const server2 = this.cache.get(id);
+        if (server2) return server2;
+      }
+      const data = yield this.client.api.get(`/servers/${id}`);
+      return this._add(data);
+    });
+  }
+};
+
+// src/managers/userManager.ts
+var UserManager = class extends BaseManager {
+  constructor() {
+    super(...arguments);
+    this.holds = User2;
+  }
+  /**
+   *
+   * @param user The user to fetch
+   * @returns A promise that resolves when the user is fetched
+   */
+  fetch(_0) {
+    return __async(this, arguments, function* (user, { force = false } = {}) {
+      const id = this.resolveId(user);
+      if (!id) throw new TypeError("INVALID_TYPE");
+      if (!force) {
+        const user2 = this.cache.get(id);
+        if (user2) return user2;
+      }
+      const data = yield this.client.api.get(`/users/${id}`);
+      return this._add(data);
+    });
+  }
+  resolve(resolvable) {
+    if (resolvable instanceof Message) return resolvable.author;
+    return super.resolve(resolvable);
+  }
+  /**
+   * get a user id form cache
+   * @param resolvable The user to resolve
+   * @returns The user id or null if it cannot be resolved
+   */
+  resolveId(resolvable) {
+    if (resolvable instanceof Message) return resolvable.authorId;
+    return super.resolveId(resolvable);
+  }
+};
+
+// src/managers/messageManager.ts
+import { File } from "node:buffer";
+import { Readable } from "stream";
+import FormData from "form-data";
+import axios from "axios";
+var MessageManager = class extends BaseManager {
+  constructor(channel) {
+    super(channel.client);
+    this.channel = channel;
+    this.holds = Message;
+  }
+  /**
+   *
+   * @param content The content to send. Can be a string or an object with the following properties:
+   * - content: The content of the message
+   * - replies: An array of message IDs to reply to
+   * - attachments: An array of attachment URLs, Files, or ReadStreams
+   * - embeds: An array of MessageEmbed objects
+   * @returns Promise that resolves to the sent message
+   */
+  send(content) {
+    return __async(this, null, function* () {
+      if (typeof content === "string") content = { content };
+      let attachments = [];
+      let embeds = [];
+      if (Array.isArray(content.attachments)) {
+        const promises = content.attachments.map((att) => __async(this, null, function* () {
+          const data = new FormData();
+          if (typeof att === "string") {
+            const readableStream = yield axios.get(att, {
+              responseType: "stream"
+            });
+            data.append("file", readableStream.data, {
+              filename: att.split("/").pop()
+            });
+          }
+          if (att instanceof Readable) {
+            data.append("file", att);
+          }
+          if (att instanceof File) {
+            const buffer = Buffer.from(yield att.arrayBuffer());
+            data.append("file", buffer, { filename: att.name });
+          }
+          yield this.client.cdn.post("/attachments", data).then((attachment) => {
+            const { id } = attachment;
+            attachments.push(id);
+          });
+        }));
+        yield Promise.all(promises);
+      }
+      if (Array.isArray(content.embeds)) {
+        const promises = content.embeds.map((embed) => __async(this, null, function* () {
+          const json = yield embed.toJSONWithMedia(this.client);
+          embeds.push(json);
+        }));
+        yield Promise.all(promises);
+      }
+      const resp = yield this.client.api.post(
+        `/channels/${this.channel.id}/messages`,
+        {
+          body: __spreadProps(__spreadValues({}, content), { attachments, embeds, nonce: UUID.generate() })
+        }
+      );
+      return this._add(resp);
+    });
+  }
+  /**
+   * acknowledge a message to mark it as read (not important for bots)
+   * @param message The message to acknowledge
+   * @returns Promise that resolves when the message is acknowledged
+   */
+  ack(message) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(message);
+      if (!id) {
+        throw new TypeError("INVALID_TYPE");
+      }
+      yield this.client.api.put(`/channels/${this.channel.id}/ack/${id}`);
+    });
+  }
+  /**
+   * bulk delete messages from the channel
+   * @param messages The messages to delete. Can be an array of message IDs or a Map of message IDs to Message objects.
+   * @returns Promise that resolves when the messages are deleted
+   */
+  bulkDelete(messages) {
+    return __async(this, null, function* () {
+      let ids = [];
+      if (typeof messages === "number") {
+        messages = yield this.fetch(messages);
+        ids = messages instanceof Map ? [...messages.keys()] : [];
+      } else if (messages instanceof Map) {
+        ids = [...messages.keys()];
+      } else {
+        ids = messages.map((m) => this.resolveId(m)).filter(Boolean);
+      }
+      yield this.client.api.delete(`/channels/${this.channel.id}/messages/bulk`, {
+        body: JSON.stringify({ ids })
+      });
+    });
+  }
+  /**
+   * delete a message from the channel
+   * @param message The message to delete. Can be a Message object or a message ID.
+   * @returns Promise that resolves when the message is deleted
+   */
+  delete(message) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(message);
+      if (!id) {
+        throw new TypeError("INVALID_TYPE");
+      }
+      yield this.client.api.delete(`/channels/${this.channel.id}/messages/${id}`);
+    });
+  }
+  /**
+   * edit a message in the channel
+   * @param message The message to edit. Can be a Message object or a message ID.
+   * @param options The options to edit the message with. Can be a string or an object with the following properties:
+   * - content: The new content of the message
+   * - attachments: An array of attachment URLs
+   * - embeds: An array of MessageEmbed objects
+   * @returns Promise that resolves when the message is edited
+   */
+  edit(message, options) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(message);
+      if (!id) {
+        throw new TypeError("INVALID_TYPE");
+      }
+      if (typeof options === "string") options = { content: options };
+      yield this.client.api.patch(`/channels/${this.channel.id}/messages/${id}`, {
+        body: options
+      });
+    });
+  }
+  /**
+   * search for messages in the channel
+   * @param query The query to search for. Can be a string or an object with the following properties:
+   * - query: The query to search for
+   * - limit: The maximum number of messages to return
+   * - before: The message ID to start searching from (exclusive)
+   * - after: The message ID to stop searching at (exclusive)
+   * - sort: The sort order of the results (asc or desc)
+   * @returns Promise that resolves to a Map of message IDs to Message objects
+   */
+  search(query) {
+    return __async(this, null, function* () {
+      if (typeof query === "string") query = { query };
+      const response = yield this.client.api.post(
+        `/channels/${this.channel.id}/search`,
+        {
+          query
+        }
+      );
+      return response.reduce((coll, cur) => {
+        const msg = this._add(cur);
+        coll.set(msg.id, msg);
+        return coll;
+      }, /* @__PURE__ */ new Map());
+    });
+  }
+  fetch(query) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(query);
+      if (id) {
+        const data = yield this.client.api.get(
+          `/channels/${this.channel.id}/messages/${id}`
+        );
+        return this._add(data);
+      }
+      if (typeof query === "number") query = { limit: query };
+      else if (typeof query === "undefined") query = { limit: 100 };
+      const messages = yield this.client.api.get(
+        `/channels/${this.channel.id}/messages`,
+        { query: JSON.stringify(query) }
+      );
+      return messages.reduce((coll, cur) => {
+        const msg = this._add(cur);
+        coll.set(msg.id, msg);
+        return coll;
+      }, /* @__PURE__ */ new Map());
+    });
+  }
+  /**
+   * add a reaction to a message
+   * @param message The message to react to. Can be a Message object or a message ID.
+   * @param emoji emoji to react with. Can be a string or an Emoji object.
+   * @returns Promise that resolves when the reaction is added
+   */
+  addReaction(message, emoji) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(message);
+      if (!id) {
+        throw new TypeError("INVALID_TYPE");
+      }
+      if (emoji instanceof Emoji) emoji = emoji.id;
+      else if (typeof emoji !== "string") {
+        throw new TypeError("INVALID_TYPE");
+      }
+      yield this.client.api.put(
+        `/channels/${this.channel.id}/messages/${id}/reactions/${emoji}`
+      );
+    });
+  }
+  /**
+   *
+   * @param message The message to unreact. Can be a Message object or a message ID.
+   * @param emoji the emoji to unreact with. Can be a string or an Emoji object.
+   * @param user_id The user ID to remove the reaction for. If not provided, removes the reaction for the current user.
+   * @param remove_all Whether to remove all of the specified reaction for the message. Defaults to false.
+   * @returns Promise that resolves when the reaction is removed
+   */
+  removeReaction(message, emoji, user_id, remove_all = false) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(message);
+      if (!id) {
+        throw new TypeError("INVALID_TYPE");
+      }
+      if (emoji instanceof Emoji) emoji = emoji.id;
+      else if (typeof emoji !== "string") {
+        throw new TypeError("INVALID_TYPE");
+      }
+      const queryString = user_id ? `?user_id=${user_id}&remove_all=${remove_all}` : `?remove_all=${remove_all}`;
+      yield this.client.api.delete(
+        `/channels/${this.channel.id}/messages/${id}/reactions/${emoji}${queryString}`
+      );
+    });
+  }
+  /**
+   * remove all reactions from a message
+   * @param message The message to remove reactions from. Can be a Message object or a message ID.
+   * @returns Promise that resolves when the reactions are removed
+   */
+  removeAllReactions(message) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(message);
+      if (!id) {
+        throw new TypeError("INVALID_TYPE");
+      }
+      yield this.client.api.delete(
+        `/channels/${this.channel.id}/messages/${id}/reactions`
+      );
+    });
+  }
+};
+
+// src/managers/roleManager.ts
+var RoleManager = class extends BaseManager {
+  constructor(server) {
+    super(server.client);
+    this.server = server;
+    this.holds = Role;
+  }
+  _add(data) {
+    const role = new Role(this.server, data);
+    this.cache.set(role.id, role);
+    return role;
+  }
+  /**
+   * creates a new role in the server
+   * @param name The name of the role to create
+   * @returns
+   */
+  create(name) {
+    return __async(this, null, function* () {
+      const { id, role } = yield this.client.api.post(`/servers/${this.server.id}/roles`, { body: { name } });
+      return this._add(Object.assign(role, { id }));
+    });
+  }
+  /**
+   * deletes a role from the server
+   * @param role the role to delete
+   * @returns A promise that resolves when the role is deleted
+   */
+  delete(role) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(role);
+      if (!id) throw new TypeError("INVALID_TYPE");
+      yield this.client.api.delete(`/servers/${this.server.id}/roles/${id}`);
+    });
+  }
+  /**
+   *
+   * @param role the role to edit
+   * @param data data to edit the role with
+   * @param data.permissions The permissions to set for the role, in the format { a: allow, d: deny }
+   * @param data.name The name of the role
+   * @param data.colour The color of the role, or `null` if no color is set
+   * @param data.hoist Whether the role is displayed separately in the member list
+   * @param data.rank The rank of the role, used for ordering
+   * @param data.remove Fields to remove from the role
+   * @returns Role
+   * @throws {TypeError} If the role ID is invalid
+   */
+  edit(role, data) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const id = this.resolveId(role);
+      if (!id) throw new TypeError("INVALID_TYPE");
+      if (data.permissions) {
+        const permissions = {
+          allow: new FullPermissions(((_a = data.permissions) == null ? void 0 : _a.a) || []).bitfield,
+          deny: new FullPermissions(((_b = data.permissions) == null ? void 0 : _b.d) || []).bitfield
+        };
+        yield this.client.api.put(
+          `/servers/${this.server.id}/permissions/${id}`,
+          { body: { permissions } }
+        );
+      }
+      delete data.permissions;
+      const updatedRole = yield this.client.api.patch(
+        `/servers/${this.server.id}/roles/${id}`,
+        { body: data }
+      );
+      return this._add(Object.assign(updatedRole, { id }));
+    });
+  }
+};
+
+// src/managers/serverChannelManager.ts
+var ServerChannelManager = class extends BaseManager {
+  constructor(server) {
+    super(server.client);
+    this.server = server;
+    this.holds = ServerChannel;
+  }
+  _add(data) {
+    let channel;
+    switch (data.channel_type) {
+      case "TextChannel":
+        channel = new TextChannel2(this.client, data);
+        break;
+      case "VoiceChannel":
+        channel = new VoiceChannel(this.client, data);
+        break;
+      default:
+        throw new Error(
+          `Unknown channel type: ${data.channel_type}`
+        );
+    }
+    this.cache.set(channel.id, channel);
+    return channel;
+  }
+  /**
+   * creates a new channel in the server
+   * @param name The name of the channel to create
+   * @param type The type of the channel to create. Can be "Text" or "Voice". Defaults to "Text".
+   * @param description The description of the channel to create. Only used for voice channels.
+   * @returns A promise that resolves to the created channel
+   */
+  create(_0) {
+    return __async(this, arguments, function* ({
+      name,
+      type = "Text",
+      description
+    }) {
+      const data = yield this.client.api.post(
+        `/servers/${this.server.id}/channels`,
+        {
+          body: {
+            name,
+            type,
+            description,
+            nonce: UUID.generate()
+          }
+        }
+      );
+      return this._add(data);
+    });
+  }
+  /**
+   * fetch a channel from the server
+   * @param channel The channel to fetch. Can be a string, a channel object, or an API channel object.
+   * @param force Whether to force fetch the channel from the API. Defaults to true.
+   * If set to false, the method will return the channel from the cache if it exists.
+   * @returns A promise that resolves to the fetched channel
+   */
+  fetch(_0) {
+    return __async(this, arguments, function* (channel, { force = true } = {}) {
+      const id = this.resolveId(channel);
+      if (!id) {
+        throw new TypeError("INVALID_ID");
+      }
+      if (!force) {
+        const channel2 = this.cache.get(id);
+        if (channel2) return channel2;
+      }
+      const data = yield this.client.api.get(
+        `/servers/${this.server.id}/channels/${id}`
+      );
+      return this._add(data);
+    });
+  }
+};
+
+// src/managers/serverMemberManager.ts
+var ServerMemberManager = class extends BaseManager {
+  constructor(server) {
+    super(server.client);
+    this.server = server;
+    this.holds = ServerMember2;
+  }
+  /**
+   * edit selected member in the server
+   * @param member The member to edit
+   * @param options The options to edit the member with
+   * @param options.nickname The nickname of the member to set
+   * @param options.avatar The avatar of the member to set
+   * @param options.roles The roles of the member to set
+   * @returns A promise that resolves when the member is edited
+   */
+  edit(member, options) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(member);
+      if (!id) {
+        throw new TypeError("INVALID_TYPE");
+      }
+      yield this.client.api.patch(`/servers/${this.server.id}/members/${id}`, {
+        body: __spreadValues({}, options)
+      });
+    });
+  }
+  /**
+   * ban selected member in the server
+   * @param member The member to ban
+   * @param reason the reason for the ban
+   * @returns A promise that resolves when the member is banned
+   */
+  ban(member, reason) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(member);
+      if (!id) {
+        throw new TypeError("INVALID_TYPE");
+      }
+      yield this.client.api.put(`/servers/${this.server.id}/bans/${id}`, {
+        body: { reason }
+      });
+    });
+  }
+  /**
+   * kick selected member in the server
+   * @param member The member to kick
+   * @returns A promise that resolves when the member is kicked
+   */
+  kick(member) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(member);
+      if (!id) {
+        throw new TypeError("INVALID_TYPE");
+      }
+      yield this.client.api.delete(`/servers/${this.server.id}/members/${id}`);
+    });
+  }
+  /**
+   * unban selected member in the server
+   * @param member The member to unban
+   * @returns A promise that resolves when the member is unbanned
+   */
+  unban(member) {
+    return __async(this, null, function* () {
+      const id = this.resolveId(member);
+      if (!id) {
+        throw new TypeError("INVALID_TYPE");
+      }
+      yield this.client.api.delete(`/servers/${this.server.id}/bans/${id}`);
+    });
+  }
+  fetch(member) {
+    return __async(this, null, function* () {
+      if (typeof member !== "undefined") {
+        const id = this.resolveId(member);
+        if (!id) {
+          throw new TypeError("INVALID_TYPE");
+        }
+        const data = yield this.client.api.get(
+          `/servers/${this.server.id}/members/${id}`
+        );
+        return this._add(data);
+      }
+      const { users, members } = yield this.client.api.get(`/servers/${this.server.id}/members`);
+      users.reduce((coll, cur) => {
+        const user = this.client.users._add(cur);
+        coll.set(user.id, user);
+        return coll;
+      }, this.client.users.cache);
+      return members.reduce((coll, cur) => {
+        const member2 = this._add(cur);
+        coll.set(member2.id, member2);
+        return coll;
+      }, /* @__PURE__ */ new Map());
+    });
+  }
+  /**
+   * resolves a member from a string or a member object
+   * @param member The member to resolve
+   * @returns The id of the member or null if it cannot be resolved
+   */
+  resolveId(member) {
+    if (member == null) return null;
+    if (member instanceof ServerMember2 || member instanceof User2) {
+      return member.id;
+    }
+    if (typeof member === "string") return member;
+    if ("_id" in member) return member._id.user;
+    return null;
+  }
+};
+
+// src/struct/server.ts
+var Server2 = class extends Base {
+  /**
+   * Creates a new Server instance.
+   *
+   * @param {client} client - The client instance.
+   * @param {APIServer} data - The raw data for the server from the API.
+   */
+  constructor(client3, data) {
+    super(client3);
+    /** The description of the server, or `null` if none is set. */
+    this.description = null;
+    /** Manages the members of the server. */
+    this.members = new ServerMemberManager(this);
+    /** Manages the channels of the server. */
+    this.channels = new ServerChannelManager(this);
+    /** Manages the roles of the server. */
+    this.roles = new RoleManager(this);
+    /** The icon of the server, or `null` if none is set. */
+    this.icon = null;
+    /** The banner of the server, or `null` if none is set. */
+    this.banner = null;
+    /** Whether analytics are enabled for the server. */
+    this.analytics = false;
+    /** Whether the server is discoverable. */
+    this.discoverable = false;
+    /** Whether the server is marked as NSFW (Not Safe For Work). */
+    this.nsfw = false;
+    /** The categories in the server. */
+    this.categories = /* @__PURE__ */ new Map();
+    /** the emojies associated with the server */
+    this.emojis = /* @__PURE__ */ new Map();
+    this._patch(data);
+  }
+  /**
+   * Updates the server instance with new data from the API.
+   *
+   * @param {APIServer} data - The raw data for the server from the API.
+   * @param {FieldsServer[]} [clear=[]] - Fields to clear in the server.
+   * @returns {this} The updated server instance.
+   * @protected
+   */
+  _patch(data, clear = []) {
+    var _a;
+    super._patch(data);
+    if (Array.isArray(data.categories)) {
+      this.categories.clear();
+      for (const cat of data.categories) {
+        const category = new Category(this, cat);
+        this.categories.set(category.id, category);
+      }
+    }
+    if (data.icon) {
+      this.icon = new Attachment(this.client, data.icon);
+    }
+    if (data.banner) {
+      this.banner = new Attachment(this.client, data.banner);
+    }
+    if (data.owner) {
+      this.ownerId = data.owner;
+    }
+    if (data.name) {
+      this.name = data.name;
+    }
+    if ("description" in data) {
+      this.description = (_a = data.description) != null ? _a : null;
+    }
+    if (Array.isArray(data.channels)) {
+      for (const id of data.channels) {
+        const channel = this.client.channels.cache.get(id);
+        if (channel == null ? void 0 : channel.inServer()) this.channels.cache.set(channel.id, channel);
+      }
+    }
+    if (typeof data.roles === "object") {
+      for (const [id, raw] of Object.entries(data.roles)) {
+        this.roles._add(Object.assign(raw, { id }));
+      }
+    }
+    if (typeof data.default_permissions === "number") {
+      this.permissions = new FullPermissions(data.default_permissions).freeze();
+    }
+    if (typeof data.analytics === "boolean") this.analytics = data.analytics;
+    if (typeof data.discoverable === "boolean") {
+      this.discoverable = data.discoverable;
+    }
+    if (typeof data.nsfw === "boolean") this.nsfw = data.nsfw;
+    for (const field of clear) {
+      if (field === "Icon") this.icon = null;
+      if (field === "Description") this.description = null;
+      if (field === "Banner") this.banner = null;
+    }
+    return this;
+  }
+  /**
+   * Retrieves the current user's member instance in the server.
+   *
+   * @returns {ServerMember | null} The current user's member instance, or `null` if not found.
+   */
+  get me() {
+    var _a, _b;
+    return (_b = this.members.cache.get((_a = this.client.user) == null ? void 0 : _a.id)) != null ? _b : null;
+  }
+  /**
+   * Gets the creation date of the server.
+   *
+   * @returns {Date} The date when the server was created.
+   */
+  get createdAt() {
+    return UUID.timestampOf(this.id);
+  }
+  /**
+   * Gets the creation timestamp of the server in milliseconds.
+   *
+   * @returns {number} The timestamp of when the server was created.
+   */
+  get createdTimestamp() {
+    return this.createdAt.getTime();
+  }
+  /**
+   * Retrieves the owner of the server.
+   *
+   * @returns {User | null} The owner of the server, or `null` if not found.
+   */
+  get owner() {
+    var _a;
+    return (_a = this.client.users.cache.get(this.ownerId)) != null ? _a : null;
+  }
+  //   iconURL(options?: { size: number }): string | null {
+  //     return this.icon
+  //       ? this.client.api.cdn.icon(this.icon.id, options?.size)
+  //       : null;
+  //   }
+  //   bannerURL(options?: { size: number }): string | null {
+  //     return this.banner
+  //       ? this.client.api.cdn.banner(this.banner.id, options?.size)
+  //       : null;
+  //   }
+  /**
+   * Converts the server to a string representation.
+   *
+   * @returns {string} The name of the server.
+   */
+  toString() {
+    return this.name;
+  }
+};
+
+// src/struct/role.ts
+var Role = class extends Base {
+  /**
+   * Creates a new Role instance.
+   *
+   * @param {Server} server - The server this role belongs to.
+   * @param {APIRole & { id: string }} data - The raw data for the role from the API.
+   */
+  constructor(server, data) {
+    super(server.client);
+    this.server = server;
+    /** The color of the role, or `null` if no color is set. */
+    this.color = null;
+    /** Whether the role is displayed separately in the member list. */
+    this.hoist = false;
+    this._patch(data);
+  }
+  /**
+   * Updates the role instance with new data from the API.
+   *
+   * @param {APIRole & { _id?: string }} data - The raw data for the role from the API.
+   * @param {FieldsRole[]} [clear=[]] - Fields to clear in the role.
+   * @returns {this} The updated role instance.
+   * @protected
+   */
+  _patch(data, clear = []) {
+    var _a;
+    super._patch(data);
+    if (data.name) this.name = data.name;
+    if (typeof data.hoist === "boolean") this.hoist = data.hoist;
+    if (typeof data.rank === "number") this.rank = data.rank;
+    if ("colour" in data) this.color = (_a = data.colour) != null ? _a : null;
+    if (data.permissions) {
+      const { a, d } = data.permissions;
+      this.overwrite = {
+        allow: new FullPermissions(a),
+        deny: new FullPermissions(d)
+      };
+    }
+    for (const field of clear) {
+      if (field === "Colour") this.color = null;
+    }
+    return this;
+  }
+  /**
+   * Gets the date when the role was created.
+   *
+   * @returns {Date} The creation date of the role.
+   */
+  get createdAt() {
+    return UUID.timestampOf(this.id);
+  }
+  /**
+   * Gets the timestamp of when the role was created.
+   *
+   * @returns {number} The creation timestamp of the role in milliseconds.
+   */
+  get createdTimestamp() {
+    return this.createdAt.getTime();
+  }
+  /**
+   * Gets the permissions overwrite for the role.
+   *
+   * @returns {Overwrite} The permissions overwrite for the role.
+   */
+  get permissions() {
+    return this.overwrite;
+  }
+  /**
+   * Deletes the role from the server.
+   *
+   * @returns {Promise<void>} A promise that resolves when the role is deleted.
+   *
+   * @example
+   * ```typescript
+   * await role.delete();
+   * console.log("Role deleted successfully.");
+   * ```
+   */
+  delete() {
+    return this.server.roles.delete(this);
+  }
+  edit(data) {
+    return this.server.roles.edit(this, data);
+  }
+  /**
+   * Converts the role to a string representation.
+   *
+   * @returns {string} A string representation of the role in the format `<@&roleId>`.
+   */
+  toString() {
+    return `<@&${this.id}>`;
+  }
+};
+
+// src/struct/clientUser.ts
+var ClientUser = class extends User2 {
+  constructor() {
+    super(...arguments);
+    /** The notes channel associated with the client user, if any. */
+    this.notes = null;
+  }
+  /**
+   * Updates the username of the client user.
+   *
+   * @param {string} username - The new username to set.
+   * @param {string} [password] - The current password of the user (required for non-bot accounts).
+   * @returns {Promise<void>} A promise that resolves when the username has been successfully updated.
+   * @throws {Error} Throws an error if the client user is a bot and a password is provided.
+   *
+   * @example
+   * ```typescript
+   * await clientUser.setUsername("NewUsername", "CurrentPassword");
+   * ```
+   */
+  setUsername(username, password) {
+    return __async(this, null, function* () {
+      if (this.bot && password) {
+        throw new Error("Bots do not have passwords");
+      }
+      yield this.client.api.patch("/users/@me/username", {
+        body: { username, password }
+      });
+    });
+  }
+  /**
+   * Updates the status of the client user.
+   *
+   * @param {string | null} text - The status text to set, or `null` to clear the status.
+   * @param {Status} [presence] - The presence status (e.g., online, idle, etc.).
+   * @returns {Promise<void>} A promise that resolves when the status has been successfully updated.
+   *
+   * @example
+   * ```typescript
+   * await clientUser.setStatus("Available", "online");
+   * ```
+   */
+  setStatus(text, presence) {
+    return __async(this, null, function* () {
+      yield this.client.api.patch("/users/@me", {
+        body: { status: { text, presence } }
+      });
+    });
+  }
+};
+
+// src/client/webSocket.ts
+var WebSocketClient = class {
+  /**
+   * Creates a new WebSocketClient instance.
+   *
+   * @param {client} client - The client instance.
+   */
+  constructor(client3) {
+    this.client = client3;
+    /** Whether the last pong acknowledgment was received. */
+    this.lastPongAck = false;
+    /** Whether the WebSocket client is connected. */
+    this.connected = false;
+    /** A promise representing the reconnecting process, or `null` if not reconnecting. */
+    this.reconnecting = null;
+    /** Whether the WebSocket client is ready. */
+    this.ready = false;
+  }
+  /**
+   * Logs a debug message.
+   *
+   * @param {unknown} message - The message to log.
+   * @private
+   */
+  debug(message) {
+    this.client.debug(`[WS] ${message}`);
+  }
+  /**
+   * Sends data through the WebSocket connection.
+   *
+   * @param {unknown} data - The data to send.
+   * @returns {Promise<void>} A promise that resolves when the data is sent.
+   * @throws {Error} Throws an error if the WebSocket is not open.
+   */
+  send(data) {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.reconnecting) {
+        this.debug("Reconnecting, waiting to send message.");
+        yield this.reconnecting;
+      }
+      if (((_a = this.socket) == null ? void 0 : _a.readyState) === WebSocket.OPEN) {
+        this.socket.send(JSON.stringify(data));
+      } else {
+        this.debug("Socket is not open, cannot send message.");
+        throw new Error("Socket is not open");
+      }
+    });
+  }
+  /**
+   * Handles the WebSocket connection opening.
+   *
+   * @private
+   */
+  onOpen() {
+    if (!this.client.token) throw new Error("Token is required");
+    this.send({
+      type: "Authenticate" /* AUTHENTICATE */,
+      token: this.client.token
+    });
+  }
+  /**
+   * Gets the current ping (latency) of the WebSocket connection.
+   *
+   * @returns {number} The ping in milliseconds, or `-0` if the WebSocket is not connected.
+   */
+  get ping() {
+    if (!this.socket) return -0;
+    return Date.now() - this.lastPingTimestamp;
+  }
+  /**
+   * Sets the heartbeat interval for the WebSocket connection.
+   *
+   * @param {number} time - The interval time in milliseconds. Use `-1` to clear the interval.
+   */
+  setHeartbeatTimer(time) {
+    this.debug(`Setting a heartbeat interval for ${time}ms.`);
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+    }
+    if (time !== -1) {
+      this.heartbeatInterval = setInterval(() => this.sendHeartbeat(), time);
+    }
+  }
+  /**
+   * Sends a heartbeat to the server to keep the connection alive.
+   */
+  sendHeartbeat() {
+    var _a;
+    this.debug("Sending heartbeat.");
+    if (!this.lastPongAck) {
+      this.debug("Did not receive a pong ack.");
+      if ((_a = this.client.options.ws) == null ? void 0 : _a.reconnect) {
+        this.reconnecting = this.destroy().then(() => this.connect()).then(() => this.reconnecting = null);
+      }
+    }
+    const now = Date.now();
+    this.send({ type: "Ping" /* PING */, data: now });
+    this.lastPongAck = false;
+    this.lastPingTimestamp = now;
+  }
+  /**
+   * Handles WebSocket errors.
+   *
+   * @param {unknown} event - The error event.
+   * @private
+   */
+  onError(event) {
+    this.client.emit("error" /* ERROR */, event);
+  }
+  /**
+   * Handles incoming WebSocket messages.
+   *
+   * @param {{ data: unknown }} param0 - The message event containing the data.
+   * @private
+   */
+  onMessage({ data }) {
+    let packet;
+    try {
+      packet = JSON.parse(String(data));
+    } catch (err) {
+      this.client.emit("error" /* ERROR */, err);
+      return;
+    }
+    this.client.emit("raw" /* RAW */, packet);
+    this.onPacket(packet).catch((e) => this.client.emit("error" /* ERROR */, e));
+  }
+  /**
+   * Handles the WebSocket connection closing.
+   *
+   * @param {{ code: number; reason: string }} event - The close event containing the code and reason.
+   * @private
+   */
+  onClose(event) {
+    this.debug(`Closed with reason: ${event.reason}, code: ${event.code}`);
+    this.destroy();
+  }
+  /**
+   * Handles incoming WebSocket packets.
+   *
+   * @param {any} packet - The packet data.
+   * @private
+   */
+  onPacket(packet) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d;
+      if (!packet) {
+        this.debug(`Received broken packet: '${packet}'.`);
+        return;
+      }
+      switch (packet.type) {
+        case "Bulk" /* BULK */:
+          yield Promise.all(packet.v.map((p) => this.onPacket(p)));
+          break;
+        case "Authenticated" /* AUTHENTICATED */:
+          this.connected = true;
+          break;
+        case "Pong" /* PONG */:
+          this.debug(`Received a heartbeat.`);
+          this.lastPongAck = true;
+          break;
+        case "Error" /* ERROR */:
+          this.client.emit("error" /* ERROR */, packet.error);
+          break;
+        case "Ready" /* READY */: {
+          this.lastPongAck = true;
+          const promises = [];
+          for (const user of packet.users) {
+            if (user.relationship === "User" && !this.client.user) {
+              this.client.user = new ClientUser(this.client, user);
+            } else {
+              this.client.users._add(user);
+            }
+          }
+          for (const server of packet.servers) {
+            const s = this.client.servers._add(server);
+            if (this.client.options.fetchMembers) {
+              promises.push(s.members.fetch());
+            }
+          }
+          for (const channel of packet.channels) {
+            this.client.channels._add(channel);
+          }
+          for (const member of packet.members) {
+            (_a = this.client.servers.cache.get(member._id.server)) == null ? void 0 : _a.members._add(member);
+          }
+          for (const emoji of packet.emojis) {
+            (_b = this.client.servers.cache.get(emoji.parent.id)) == null ? void 0 : _b.emojis.set(emoji._id, __spreadProps(__spreadValues({}, emoji), { _id: emoji._id }));
+          }
+          this.setHeartbeatTimer(
+            (_d = (_c = this.client.options.ws) == null ? void 0 : _c.heartbeatInterval) != null ? _d : 3e4
+          );
+          yield Promise.all(promises);
+          this.ready = true;
+          this.client.emit("ready" /* READY */, this.client);
+          break;
+        }
+        default: {
+          const action = this.client.events.get(packet.type);
+          if (action) {
+            yield action.handle(packet);
+          } else {
+            this.debug(`Received unknown packet "${packet.type}"`);
+          }
+          break;
+        }
+      }
+    });
+  }
+  /**
+   * Connects to the WebSocket server.
+   *
+   * @returns {Promise<this>} A promise that resolves when the connection is established.
+   */
+  connect() {
+    return new Promise((resolve) => {
+      var _a, _b;
+      if (((_a = this.socket) == null ? void 0 : _a.readyState) === WebSocket.OPEN && this.ready) {
+        return resolve(this);
+      }
+      if (typeof this.client.options === "undefined") {
+        throw new Error("MISSING_CONFIGURATION_SYNC");
+      }
+      if (typeof this.client.token !== "string") {
+        throw new Error("INVALID_TOKEN");
+      }
+      const ws = this.socket = (_b = this.socket) != null ? _b : new WebSocket(`${wsUrl}`);
+      ws.onopen = this.onOpen.bind(this);
+      ws.onmessage = this.onMessage.bind(this);
+      ws.onerror = this.onError.bind(this);
+      ws.onclose = this.onClose.bind(this);
+      ws.addEventListener("open", () => resolve(this));
+    });
+  }
+  /**
+   * Destroys the WebSocket connection and clears its state.
+   *
+   * @returns {Promise<void>} A promise that resolves when the connection is destroyed.
+   */
+  destroy() {
+    return new Promise((resolve) => {
+      var _a;
+      this.setHeartbeatTimer(-1);
+      this.connected = false;
+      this.ready = false;
+      if (((_a = this.socket) == null ? void 0 : _a.readyState) === WebSocket.OPEN) {
+        this.socket.addEventListener("close", () => {
+          this.socket = null;
+          resolve();
+        });
+        this.socket.close();
+      } else {
+        this.socket = null;
+        resolve();
+      }
+    });
+  }
+};
+
+// src/client/client.ts
+var client = class extends BaseClient {
+  constructor() {
+    super(...arguments);
+    /** The WebSocket client used for real-time communication. */
+    this.ws = new WebSocketClient(this);
+    /** Manages the channels in the client. */
+    this.channels = new ChannelManager(this);
+    /** Manages the servers in the client. */
+    this.servers = new ServerManager(this);
+    /** Manages the users in the client. */
+    this.users = new UserManager(this);
+    /** Manages the events in the client. */
+    this.events = new EventManager(this);
+    /** The authenticated user, or `null` if not logged in. */
+    this.user = null;
+    /** The timestamp when the client became ready, or `null` if not ready. */
+    this.readyAt = null;
+  }
+  /**
+   * Gets the timestamp when the client became ready.
+   *
+   * @returns {number | null} The ready timestamp in milliseconds, or `null` if not ready.
+   */
+  get readyTimestamp() {
+    return this.readyAt ? this.readyAt.getTime() : null;
+  }
+  /**
+   * Gets the uptime of the client in milliseconds.
+   *
+   * @returns {number | null} The uptime in milliseconds, or `null` if the client is not ready.
+   */
+  get upTime() {
+    return this.readyAt ? Date.now() - this.readyAt.getTime() : null;
+  }
+  /**
+   * Logs the client into the API using the provided token.
+   *
+   * @param {string} token - The authentication token.
+   * @returns {Promise<void>} A promise that resolves when the client is logged in.
+   * @throws {Error} Throws an error if the token is not provided or if the WebSocket connection fails.
+   *
+   * @example
+   * ```typescript
+   * await client.login("your-token-here");
+   * ```
+   */
+  login(token) {
+    return __async(this, null, function* () {
+      if (!token) throw new Error("Token is required");
+      this.token = token;
+      this.debug("Logging in...");
+      try {
+        yield this.ws.connect();
+      } catch (error) {
+        this.debug(`Error connecting to WebSocket: ${error}`);
+        throw error;
+      }
+      this.readyAt = /* @__PURE__ */ new Date();
+    });
+  }
+  /**
+   * Destroys the client, disconnecting it from the API and clearing its state.
+   *
+   * @returns {Promise<void>} A promise that resolves when the client is destroyed.
+   *
+   * @example
+   * ```typescript
+   * await client.destroy();
+   * ```
+   */
+  destroy() {
+    return __async(this, null, function* () {
+      this.token = null;
+      this.user = null;
+      this.readyAt = null;
+      yield this.ws.destroy();
+    });
+  }
+  /**
+   * Checks if the client is ready.
+   *
+   * @returns {boolean} `true` if the client is ready, otherwise `false`.
+   *
+   * @example
+   * ```typescript
+   * if (client.isReady()) {
+   *   console.log("Client is ready!");
+   * }
+   * ```
+   */
+  isReady() {
+    return this.readyAt !== null;
+  }
+};
+
+// src/struct/dmChannel.ts
+var DMChannel2 = class extends Channel {
+  /**
+   * Creates a new DMChannel instance.
+   *
+   * @param {client} client - The client instance.
+   * @param {APIDirectChannel} data - The raw data for the DM channel from the API.
+   */
+  constructor(client3, data) {
+    super(client3);
+    /** The type of the channel, which is always `DM` for direct message channels. */
+    this.type = "DM" /* DM */;
+    /** The default permissions for the DM channel. */
+    this.permissions = DEFAULT_PERMISSION_DM;
+    /** Manages the messages in this DM channel. */
+    this.messages = new MessageManager(this);
+    /** The ID of the last message sent in this DM channel, if any. */
+    this.lastMessageId = null;
+    this._patch(data);
+  }
+  /**
+   * Updates the DM channel instance with new data from the API.
+   *
+   * @param {APIDirectChannel} data - The raw data for the DM channel from the API.
+   * @returns {this} The updated DM channel instance.
+   * @protected
+   */
+  _patch(data) {
+    super._patch(data);
+    if (typeof data.active === "boolean") this.active = data.active;
+    if (data.last_message_id) this.lastMessageId = data.last_message_id;
+    return this;
+  }
+  /**
+   * Retrieves the last message sent in this DM channel.
+   *
+   * @returns {Message | null} The last message, or `null` if no message exists.
+   */
+  get lastMessage() {
+    var _a;
+    if (!this.lastMessageId) return null;
+    return (_a = this.messages.cache.get(this.lastMessageId)) != null ? _a : null;
+  }
+  /**
+   * Deletes multiple messages from this DM channel.
+   *
+   * @param {MessageResolvable[] | Map<string, Message> | number} messages - The messages to delete. This can be an array of message resolvables, a map of messages, or a number indicating how many recent messages to delete.
+   * @returns {Promise<void>} A promise that resolves when the messages have been successfully deleted.
+   *
+   * @example
+   * ```typescript
+   * await dmChannel.bulkDelete(10); // Deletes the last 10 messages.
+   * ```
+   */
+  bulkDelete(messages) {
+    return this.messages.bulkDelete(messages);
+  }
+  /**
+   * Sends a message to this DM channel.
+   *
+   * @param {MessageOptions | string} options - The message content or options for the message.
+   * @returns {Promise<Message>} A promise that resolves with the sent message.
+   *
+   * @example
+   * ```typescript
+   * await dmChannel.send("Hello, world!");
+   * ```
+   */
+  send(options) {
+    return this.messages.send(options);
+  }
+};
+
+// src/struct/groupChannel.ts
+var GroupChannel2 = class extends Channel {
+  /**
+   * Creates a new GroupChannel instance.
+   *
+   * @param {client} client - The client instance.
+   * @param {APIGroupChannel} data - The raw data for the group channel from the API.
+   */
+  constructor(client3, data) {
+    super(client3);
+    /** The type of the channel, which is always `GROUP` for group channels. */
+    this.type = "GROUP" /* GROUP */;
+    /** The description of the group channel, if any. */
+    this.description = null;
+    /** The icon of the group channel, if any. */
+    this.icon = null;
+    /** Manages the messages in this group channel. */
+    this.messages = new MessageManager(this);
+    /** The ID of the last message sent in this group channel, if any. */
+    this.lastMessageId = null;
+    /** A map of user IDs to their corresponding `User` instances in the group channel. */
+    this.users = /* @__PURE__ */ new Map();
+    /** Whether the group channel is marked as NSFW (Not Safe For Work). */
+    this.nsfw = false;
+    this._patch(data);
+  }
+  /**
+   * Updates the group channel instance with new data from the API.
+   *
+   * @param {APIGroupChannel} data - The raw data for the group channel from the API.
+   * @returns {this} The updated group channel instance.
+   * @protected
+   */
+  _patch(data) {
+    var _a;
+    super._patch(data);
+    if ("description" in data) {
+      this.description = (_a = data.description) != null ? _a : null;
+    }
+    if (Array.isArray(data.recipients)) {
+      this.users.clear();
+      for (const userId of data.recipients) {
+        const user = this.client.users.cache.get(userId);
+        if (user) this.users.set(user.id, user);
+      }
+    }
+    if (typeof data.permissions === "number") {
+      this.permissions = new ChannelPermissions(data.permissions).freeze();
+    }
+    if (data.owner) {
+      this.ownerId = data.owner;
+    }
+    if (data.icon) {
+      this.icon = new Attachment(this.client, data.icon);
+    }
+    if (data.name) {
+      this.name = data.name;
+    }
+    if (data.last_message_id) this.lastMessageId = data.last_message_id;
+    if (typeof data.nsfw === "boolean") this.nsfw = data.nsfw;
+    return this;
+  }
+  /**
+   * Retrieves the last message sent in this group channel.
+   *
+   * @returns {Message | null} The last message, or `null` if no message exists.
+   */
+  get lastMessage() {
+    var _a;
+    if (!this.lastMessageId) return null;
+    return (_a = this.messages.cache.get(this.lastMessageId)) != null ? _a : null;
+  }
+  /**
+   * Retrieves the owner of the group channel.
+   *
+   * @returns {User | null} The owner of the group channel, or `null` if not found.
+   */
+  get owner() {
+    var _a;
+    return (_a = this.client.users.cache.get(this.ownerId)) != null ? _a : null;
+  }
+  /**
+   * Deletes multiple messages from this group channel.
+   *
+   * @param {MessageResolvable[] | Map<string, Message> | number} messages - The messages to delete. This can be an array of message resolvables, a map of messages, or a number indicating how many recent messages to delete.
+   * @returns {Promise<void>} A promise that resolves when the messages have been successfully deleted.
+   *
+   * @example
+   * ```typescript
+   * await groupChannel.bulkDelete(10); // Deletes the last 10 messages.
+   * ```
+   */
+  bulkDelete(messages) {
+    return this.messages.bulkDelete(messages);
+  }
+  /**
+   * Creates an invite for the group channel.
+   *
+   * @returns {Promise<Invite>} A promise that resolves with the created invite.
+   *
+   * @example
+   * ```typescript
+   * const invite = await groupChannel.createInvite();
+   * console.log(`Invite created: ${invite}`);
+   * ```
+   */
+  createInvite() {
+    return __async(this, null, function* () {
+      const data = yield this.client.api.post(`/channels/${this.id}/invites`, {});
+      return new Invite(
+        this.client,
+        data
+      );
+    });
+  }
+  /**
+   * Adds a user to the group channel.
+   *
+   * @param {UserResolvable} user - The user to add to the group channel.
+   * @returns {Promise<void>} A promise that resolves when the user has been successfully added.
+   *
+   * @example
+   * ```typescript
+   * await groupChannel.add(user);
+   * ```
+   */
+  add(user) {
+    return __async(this, null, function* () {
+      const id = this.client.users.resolveId(user);
+      if (!id) throw new TypeError("INVALID_TYPE");
+      yield this.client.api.put(`/channels/${this.id}/recipients/${id}`);
+    });
+  }
+  /**
+   * Removes a user from the group channel.
+   *
+   * @param {UserResolvable} user - The user to remove from the group channel.
+   * @returns {Promise<void>} A promise that resolves when the user has been successfully removed.
+   *
+   * @example
+   * ```typescript
+   * await groupChannel.remove(user);
+   * ```
+   */
+  remove(user) {
+    return __async(this, null, function* () {
+      const id = this.client.users.resolveId(user);
+      if (!id) throw new TypeError("INVALID_TYPE");
+      yield this.client.api.delete(`/channels/${this.id}/recipients/${id}`);
+    });
+  }
+  /**
+   * Leaves the group channel.
+   *
+   * @returns {Promise<void>} A promise that resolves when the group channel has been successfully left.
+   *
+   * @example
+   * ```typescript
+   * await groupChannel.leave();
+   * ```
+   */
+  leave() {
+    return super.delete();
+  }
+  /**
+   * Sends a message to this group channel.
+   *
+   * @param {MessageOptions | string} options - The message content or options for the message.
+   * @returns {Promise<Message>} A promise that resolves with the sent message.
+   *
+   * @example
+   * ```typescript
+   * await groupChannel.send("Hello, group!");
+   * ```
+   */
+  send(options) {
+    return this.messages.send(options);
+  }
+  //   iconURL(options?: { size: number }): string | null {
+  //     if (!this.icon) return null;
+  //     return this.client.api.cdn.icon(this.icon.id, options?.size);
+  //   }
+};
+
+// src/struct/notesChannel.ts
+var NotesChannel = class extends Channel {
+  /**
+   * Creates a new NotesChannel instance.
+   *
+   * @param {client} client - The client instance.
+   * @param {APINotesChannel} data - The raw data for the notes channel from the API.
+   */
+  constructor(client3, data) {
+    super(client3);
+    /** The type of the channel, which is always `NOTES` for notes channels. */
+    this.type = "NOTES" /* NOTES */;
+    /** The ID of the last message sent in this notes channel, if any. */
+    this.lastMessageId = null;
+    /** Manages the messages in this notes channel. */
+    this.messages = new MessageManager(this);
+    this._patch(data);
+  }
+  /**
+   * Updates the notes channel instance with new data from the API.
+   *
+   * @param {APINotesChannel} data - The raw data for the notes channel from the API.
+   * @returns {this} The updated notes channel instance.
+   * @protected
+   */
+  _patch(data) {
+    super._patch(data);
+    if (data.user) {
+      this.userId = data.user;
+    }
+    return this;
+  }
+  /**
+   * Sends a message to this notes channel.
+   *
+   * @param {MessageOptions | string} options - The message content or options for the message.
+   * @returns {Promise<Message>} A promise that resolves with the sent message.
+   *
+   * @example
+   * ```typescript
+   * await notesChannel.send("This is a saved message.");
+   * ```
+   */
+  send(options) {
+    return this.messages.send(options);
+  }
+  /**
+   * Deletes multiple messages from this notes channel.
+   *
+   * @param {MessageResolvable[] | Map<string, Message> | number} messages - The messages to delete. This can be an array of message resolvables, a map of messages, or a number indicating how many recent messages to delete.
+   * @returns {Promise<void>} A promise that resolves when the messages have been successfully deleted.
+   *
+   * @example
+   * ```typescript
+   * await notesChannel.bulkDelete(5); // Deletes the last 5 messages.
+   * ```
+   */
+  bulkDelete(messages) {
+    return this.messages.bulkDelete(messages);
+  }
+  /**
+   * Retrieves the last message sent in this notes channel.
+   *
+   * @returns {Message | null} The last message, or `null` if no message exists.
+   */
+  get lastMessage() {
+    var _a;
+    if (!this.lastMessageId) return null;
+    return (_a = this.messages.cache.get(this.lastMessageId)) != null ? _a : null;
+  }
+  /**
+   * Retrieves the user associated with this notes channel.
+   *
+   * @returns {User} The user associated with the notes channel.
+   */
+  get user() {
+    return this.client.user;
+  }
+};
+
+// src/struct/serverChannel.ts
+var ServerChannel = class extends Channel {
+  /**
+   * Creates a new ServerChannel instance.
+   *
+   * @param {client} client - The client instance.
+   * @param {APIServerChannel} data - The raw data for the server channel from the API.
+   */
+  constructor(client3, data) {
+    super(client3);
+    /** The description of the channel, or `null` if none is set. */
+    this.description = null;
+    /** The icon of the channel, or `null` if none is set. */
+    this.icon = null;
+    /** The permission overwrites for the channel. */
+    this.overwrites = /* @__PURE__ */ new Map();
+    /** Whether the channel is marked as NSFW (Not Safe For Work). */
+    this.nsfw = false;
+    this._patch(data);
+  }
+  /**
+   * Updates the server channel instance with new data from the API.
+   *
+   * @param {APIServerChannel} data - The raw data for the server channel from the API.
+   * @param {FieldsChannel[]} [clear=[]] - Fields to clear in the channel.
+   * @returns {this} The updated server channel instance.
+   * @protected
+   */
+  _patch(data, clear = []) {
+    var _a;
+    super._patch(data);
+    if (data.name) this.name = data.name;
+    if (data.server) this.serverId = data.server;
+    if ("description" in data) this.description = (_a = data.description) != null ? _a : null;
+    if (data.icon) this.icon = new Attachment(this.client, data.icon);
+    if (typeof data.nsfw === "boolean") this.nsfw = data.nsfw;
+    if (data.role_permissions) {
+      this.overwrites.clear();
+      for (const [id, { a, d }] of Object.entries(data.role_permissions)) {
+        this.overwrites.set(id, {
+          allow: new FullPermissions(a),
+          deny: new FullPermissions(d)
+        });
+      }
+    }
+    for (const field of clear) {
+      if (field === "Icon") this.icon = null;
+      if (field === "Description") this.description = null;
+    }
+    return this;
+  }
+  /**
+   * Creates an invite for the server channel.
+   *
+   * @returns {Promise<Invite>} A promise that resolves with the created invite.
+   *
+   * @example
+   * ```typescript
+   * const invite = await serverChannel.createInvite();
+   * console.log(`Invite created: ${invite}`);
+   * ```
+   */
+  createInvite() {
+    return __async(this, null, function* () {
+      const data = yield this.client.api.post(`/channels/${this.id}/invites`, {});
+      return new Invite(
+        this.client,
+        data
+      );
+    });
+  }
+  //   iconURL(options?: { size: number }): string | null {
+  //     return this.icon
+  //       ? this.client.api.cdn.icon(this.icon.id, options?.size)
+  //       : null;
+  //   }
+  /**
+   * Retrieves the server this channel belongs to.
+   *
+   * @returns {Server} The server instance.
+   */
+  get server() {
+    return this.client.servers.cache.get(this.serverId);
+  }
+  /**
+   * Retrieves the category this channel belongs to, if any.
+   *
+   * @returns {Category | null} The category instance, or `null` if the channel is not in a category.
+   */
+  get category() {
+    var _a;
+    return (_a = Array.from(this.server.categories.values()).find(
+      (cat) => cat.children.has(this.id)
+    )) != null ? _a : null;
+  }
+};
+
+// src/struct/serverMember.ts
+var ServerMember2 = class extends Base {
+  /**
+   * Creates a new ServerMember instance.
+   *
+   * @param {client} client - The client instance.
+   * @param {APIMember} data - The raw data for the server member from the API.
+   */
+  constructor(client3, data) {
+    super(client3);
+    /** The nickname of the member, or `null` if none is set. */
+    this.nickname = null;
+    /** The avatar of the member, or `null` if none is set. */
+    this.avatar = null;
+    /** roles assigned to the member */
+    this.roles = [];
+    this._patch(data);
+  }
+  /**
+   * Updates the server member instance with new data from the API.
+   *
+   * @param {APIMember} data - The raw data for the server member from the API.
+   * @param {FieldsMember[]} [clear=[]] - Fields to clear in the server member.
+   * @returns {this} The updated server member instance.
+   * @protected
+   */
+  _patch(data, clear = []) {
+    var _a;
+    super._patch(data);
+    if ("nickname" in data) {
+      this.nickname = (_a = data.nickname) != null ? _a : null;
+    }
+    if (data.avatar) {
+      this.avatar = new Attachment(this.client, data.avatar);
+    }
+    if (data._id) {
+      this.serverId = data._id.server;
+      this.id = data._id.user;
+    }
+    if (Array.isArray(data.roles)) {
+      if (!data.roles.length) this.roles = [];
+      else {
+        this.roles = data.roles.map((roleId) => {
+          const role = this.server.roles.cache.get(roleId);
+          if (!role) {
+            throw new Error(
+              `Role with ID ${roleId} not found in server ${this.serverId}`
+            );
+          }
+          return role;
+        });
+      }
+    }
+    for (const field of clear) {
+      if (field === "Avatar") this.avatar = null;
+      if (field === "Nickname") this.nickname = null;
+    }
+    return this;
+  }
+  /**
+   * Sets the nickname of the server member.
+   *
+   * @param {string} [nickname] - The new nickname to set, or `undefined` to clear the nickname.
+   * @returns {Promise<this>} A promise that resolves with the updated server member instance.
+   *
+   * @example
+   * ```typescript
+   * await member.setNickname("NewNickname");
+   * ```
+   */
+  setNickname(nickname) {
+    return __async(this, null, function* () {
+      yield this.server.members.edit(this, { nickname });
+      return this;
+    });
+  }
+  /**
+   * adds a role to the server member.
+   * @param roleId - The ID of the role to add to the member.
+   * @returns
+   */
+  addRole(roleId) {
+    return __async(this, null, function* () {
+      const currentRoles = this.roles.map((role) => role.id);
+      if (currentRoles.includes(roleId)) {
+        return this;
+      }
+      yield this.server.members.edit(this, {
+        roles: [...currentRoles, roleId]
+      });
+      return this;
+    });
+  }
+  /**
+   * Removes a role from the server member.
+   *
+   * @param {string} roleId - The ID of the role to remove from the member.
+   * @returns {Promise<this>} A promise that resolves with the updated server member instance.
+   *
+   * @example
+   * ```typescript
+   * await member.removeRole("roleId");
+   * ```
+   */
+  removeRole(roleId) {
+    return __async(this, null, function* () {
+      const currentRoles = this.roles.map((role) => role.id);
+      if (!currentRoles.includes(roleId)) {
+        return this;
+      }
+      yield this.server.members.edit(this, {
+        roles: currentRoles.filter((id) => id !== roleId)
+      });
+      return this;
+    });
+  }
+  /**
+   * Bans the server member.
+   *
+   * @param {string} [reason] - The reason for the ban.
+   * @returns {Promise<void>} A promise that resolves when the member is banned.
+   *
+   * @example
+   * ```typescript
+   * await member.ban("Violation of rules");
+   * ```
+   */
+  ban(reason) {
+    return this.server.members.ban(this, reason);
+  }
+  /**
+   * Kicks the server member.
+   *
+   * @returns {Promise<void>} A promise that resolves when the member is kicked.
+   *
+   * @example
+   * ```typescript
+   * await member.kick();
+   * ```
+   */
+  kick() {
+    return this.server.members.kick(this);
+  }
+  /**
+   * Leaves the server.
+   *
+   * @returns {Promise<void>} A promise that resolves when the member leaves the server.
+   *
+   * @example
+   * ```typescript
+   * await member.leave();
+   * ```
+   */
+  leave() {
+    return this.client.servers.delete(this.serverId);
+  }
+  //   async displayAvatarURL(options?: { size: number }): Promise<string> {
+  //     return await this.user.displayAvatarURL(options);
+  //   }
+  /**
+   * Retrieves the user associated with this server member.
+   *
+   * @returns {User} The user instance.
+   */
+  get user() {
+    return this.client.users.cache.get(this.id);
+  }
+  /**
+   * Retrieves the server this member belongs to.
+   *
+   * @returns {Server} The server instance.
+   */
+  get server() {
+    return this.client.servers.cache.get(this.serverId);
+  }
+  /**
+   * Converts the server member to a string representation.
+   *
+   * @returns {string} A string representation of the server member in the format `<@userId>`.
+   */
+  toString() {
+    return `<@${this.id}>`;
+  }
+};
+
+// src/struct/textChannel.ts
+var TextChannel2 = class extends ServerChannel {
+  /**
+   * Creates a new TextChannel instance.
+   *
+   * @param {client} client - The client instance.
+   * @param {APITextChannel} data - The raw data for the text channel from the API.
+   */
+  constructor(client3, data) {
+    super(client3, data);
+    /** The ID of the last message sent in this text channel, if any. */
+    this.lastMessageId = null;
+    /** Manages the messages in this text channel. */
+    this.messages = new MessageManager(this);
+    /** The type of the channel, which is always `TEXT` for text channels. */
+    this.type = "TEXT" /* TEXT */;
+    this._patch(data);
+  }
+  /**
+   * Updates the text channel instance with new data from the API.
+   *
+   * @param {APITextChannel} data - The raw data for the text channel from the API.
+   * @returns {this} The updated text channel instance.
+   * @protected
+   */
+  _patch(data) {
+    super._patch(data);
+    if (data.last_message_id) this.lastMessageId = data.last_message_id;
+    return this;
+  }
+  /**
+   * Retrieves the last message sent in this text channel.
+   *
+   * @returns {Message | null} The last message, or `null` if no message exists.
+   */
+  get lastMessage() {
+    var _a;
+    if (!this.lastMessageId) return null;
+    return (_a = this.messages.cache.get(this.lastMessageId)) != null ? _a : null;
+  }
+  /**
+   * Sends a message to this text channel.
+   *
+   * @param {MessageOptions | string} options - The message content or options for the message.
+   * @returns {Promise<Message>} A promise that resolves with the sent message.
+   *
+   * @example
+   * ```typescript
+   * await textChannel.send("Hello, world!");
+   * ```
+   */
+  send(options) {
+    return this.messages.send(options);
+  }
+  /**
+   * Deletes multiple messages from this text channel.
+   *
+   * @param {MessageResolvable[] | Map<string, Message> | number} messages - The messages to delete. This can be an array of message resolvables, a map of messages, or a number indicating how many recent messages to delete.
+   * @returns {Promise<void>} A promise that resolves when the messages have been successfully deleted.
+   *
+   * @example
+   * ```typescript
+   * await textChannel.bulkDelete(10); // Deletes the last 10 messages.
+   * ```
+   */
+  bulkDelete(messages) {
+    return this.messages.bulkDelete(messages);
+  }
+};
+
+// src/struct/voiceChannels.ts
+var VoiceChannel = class extends ServerChannel {
+  /**
+   * Creates a new VoiceChannel instance.
+   *
+   * @param {client} client - The client instance.
+   * @param {APIVoiceChannel} data - The raw data for the voice channel from the API.
+   */
+  constructor(client3, data) {
+    super(client3, data);
+    /** The type of the channel, which is always `VOICE` for voice channels. */
+    this.type = "VOICE" /* VOICE */;
+    this._patch(data);
+  }
+  /**
+   * Updates the voice channel instance with new data from the API.
+   *
+   * @param {APIVoiceChannel} data - The raw data for the voice channel from the API.
+   * @returns {this} The updated voice channel instance.
+   * @protected
+   */
+  _patch(data) {
+    super._patch(data);
+    return this;
+  }
+  /**
+   * Acknowledges the voice channel.
+   *
+   * @throws {TypeError} Throws an error because voice channels cannot be acknowledged.
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   await voiceChannel.ack();
+   * } catch (error) {
+   *   console.error(error.message); // "Cannot ack voice channel"
+   * }
+   * ```
+   */
+  ack() {
+    throw new TypeError("Cannot ack voice channel");
+  }
+};
+
+// src/struct/category.ts
+var Category = class extends Base {
+  /**
+   * Creates a new Category instance.
+   *
+   * @param {Server} server - The server this category belongs to.
+   * @param {APICategory} data - The raw data for the category from the API.
+   */
+  constructor(server, data) {
+    super(server.client);
+    this.server = server;
+    /** An array of channel IDs that belong to this category. */
+    this._children = [];
+    this._patch(data);
+  }
+  /**
+   * Updates the category instance with new data from the API.
+   *
+   * @param {APICategory} data - The raw data for the category from the API.
+   * @returns {this} The updated category instance.
+   * @protected
+   */
+  _patch(data) {
+    super._patch(data);
+    if (data.title) {
+      this.name = data.title;
+    }
+    if (Array.isArray(data.channels)) {
+      this._children = data.channels;
+    }
+    return this;
+  }
+  /**
+   * Retrieves the channels that belong to this category.
+   *
+   * @returns {Map<string, ServerChannel>} A map of channel IDs to their corresponding `ServerChannel` instances.
+   */
+  get children() {
+    const coll = /* @__PURE__ */ new Map();
+    for (const childId of this._children) {
+      const child = this.server.channels.cache.get(childId);
+      if (child) coll.set(child.id, child);
+    }
+    return coll;
+  }
+  /**
+   * Converts the category to a string representation.
+   *
+   * @returns {string} The name of the category.
+   */
+  toString() {
+    return this.name;
+  }
+};
+
+// src/struct/user.ts
+var User2 = class extends Base {
+  /**
+   * Creates a new User instance.
+   *
+   * @param {client} client - The client instance.
+   * @param {APIUser} data - The raw data for the user from the API.
+   */
+  constructor(client3, data) {
+    super(client3);
+    /** The avatar of the user, or `null` if none is set. */
+    this.avatar = null;
+    /** The presence status of the user. */
+    this.presence = new Presence(this.client);
+    /** Whether the user is a bot. */
+    this.bot = false;
+    this._patch(data);
+  }
+  /**
+   * Updates the user instance with new data from the API.
+   *
+   * @param {APIUser} data - The raw data for the user from the API.
+   * @param {FieldsUser[]} [clear=[]] - Fields to clear in the user.
+   * @returns {this} The updated user instance.
+   * @protected
+   */
+  _patch(data, clear = []) {
+    var _a, _b;
+    super._patch(data);
+    if (data.username) {
+      this.username = data.username;
+    }
+    if (data.bot) {
+      this.bot = true;
+    }
+    if (typeof data.badges === "number") {
+      this.badges = new Badges(data.badges).freeze();
+    }
+    if (data.avatar) {
+      this.avatar = new Attachment(this.client, data.avatar);
+    }
+    if (data.status) {
+      this.presence.status = data.status.presence ? (_a = Status[data.status.presence]) != null ? _a : "OFFLINE" /* Invisible */ : "OFFLINE" /* Invisible */;
+      this.presence.text = (_b = data.status.text) != null ? _b : null;
+    }
+    for (const field of clear) {
+      if (field === "Avatar") this.avatar = null;
+      if (field === "StatusText") this.presence.text = null;
+      if (field === "StatusPresence") this.presence.status = "OFFLINE" /* Invisible */;
+    }
+    return this;
+  }
+  /**
+   * Gets the creation date of the user.
+   *
+   * @returns {Date} The date when the user was created.
+   */
+  get createdAt() {
+    return UUID.timestampOf(this.id);
+  }
+  /**
+   * Gets the creation timestamp of the user in milliseconds.
+   *
+   * @returns {number} The timestamp of when the user was created.
+   */
+  get createdTimestamp() {
+    return this.createdAt.getTime();
+  }
+  /**
+   * Blocks the user.
+   *
+   * @returns {Promise<void>} A promise that resolves when the user is blocked.
+   *
+   * @example
+   * ```typescript
+   * await user.block();
+   * ```
+   */
+  block() {
+    return __async(this, null, function* () {
+      yield this.client.api.put(`/users/${this.id}/block`);
+    });
+  }
+  /**
+   * Unblocks the user.
+   *
+   * @returns {Promise<void>} A promise that resolves when the user is unblocked.
+   *
+   * @example
+   * ```typescript
+   * await user.unblock();
+   * ```
+   */
+  unblock() {
+    return __async(this, null, function* () {
+      yield this.client.api.delete(`/users/${this.id}/block`);
+    });
+  }
+  /**
+   * Creates a direct message (DM) channel with the user.
+   *
+   * @returns {Promise<DMChannel>} A promise that resolves with the created DM channel.
+   *
+   * @example
+   * ```typescript
+   * const dmChannel = await user.createDM();
+   * ```
+   */
+  createDM() {
+    return __async(this, null, function* () {
+      const data = yield this.client.api.get(`/users/${this.id}/dm`);
+      return this.client.channels._add(data);
+    });
+  }
+  avatarURL() {
+    var _a, _b;
+    if (!((_a = this.avatar) == null ? void 0 : _a.id)) return void 0;
+    return `${cdnUrl}/avatars/${(_b = this.avatar) == null ? void 0 : _b.id}`;
+  }
+  displayAvatarURL() {
+    return __async(this, null, function* () {
+      var _a;
+      const defaultAvatar = `${cdnUrl}/users/${this.id}/default_avatar`;
+      return (_a = this.avatarURL()) != null ? _a : defaultAvatar;
+    });
+  }
+  /**
+   * Fetches the latest data for the user from the API.
+   *
+   * @param {boolean} [force=false] - Whether to force a fetch even if the user is cached.
+   * @returns {Promise<User>} A promise that resolves with the updated user instance.
+   */
+  fetch(force = false) {
+    return this.client.users.fetch(this, { force });
+  }
+  /**
+   * Converts the user to a string representation.
+   *
+   * @returns {string} A string representation of the user in the format `<@userId>`.
+   */
+  toString() {
+    return `<@${this.id}>`;
+  }
+};
+
+export {
+  User2 as User,
+  Message,
+  Server2 as Server,
+  Role,
+  DMChannel2 as DMChannel,
+  GroupChannel2 as GroupChannel,
+  NotesChannel,
+  ServerChannel,
+  ServerMember2 as ServerMember,
+  TextChannel2 as TextChannel,
+  VoiceChannel,
+  Category,
+  ChannelManager,
+  ServerManager,
+  UserManager,
+  MessageManager,
+  RoleManager,
+  ServerChannelManager,
+  ServerMemberManager,
+  ClientUser,
+  WebSocketClient,
+  client
+};
+//# sourceMappingURL=chunk-XQEYCTYC.js.map