@fluxerjs/core 1.0.8 → 1.1.0

package/dist/index.js

@@ -20,6 +20,72 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/errors/FluxerError.ts
+var FluxerError;
+var init_FluxerError = __esm({
+  "src/errors/FluxerError.ts"() {
+    "use strict";
+    FluxerError = class _FluxerError extends Error {
+      code;
+      constructor(message, options) {
+        super(message, options?.cause ? { cause: options.cause } : void 0);
+        this.name = "FluxerError";
+        this.code = options?.code;
+        Object.setPrototypeOf(this, _FluxerError.prototype);
+      }
+    };
+  }
+});
+
+// src/errors/ErrorCodes.ts
+var ErrorCodes;
+var init_ErrorCodes = __esm({
+  "src/errors/ErrorCodes.ts"() {
+    "use strict";
+    ErrorCodes = {
+      ClientNotReady: "CLIENT_NOT_READY",
+      InvalidToken: "INVALID_TOKEN",
+      AlreadyLoggedIn: "ALREADY_LOGGED_IN",
+      ChannelNotFound: "CHANNEL_NOT_FOUND",
+      MessageNotFound: "MESSAGE_NOT_FOUND",
+      GuildNotFound: "GUILD_NOT_FOUND",
+      MemberNotFound: "MEMBER_NOT_FOUND"
+    };
+  }
+});
+
+// src/util/messageUtils.ts
+function buildSendBody(options) {
+  const body = typeof options === "string" ? { content: options } : options;
+  const result = {};
+  if (body.content !== void 0) result.content = body.content;
+  if (body.embeds?.length) {
+    result.embeds = body.embeds.map((e) => e instanceof import_builders.EmbedBuilder ? e.toJSON() : e);
+  }
+  if (body.files?.length && body.attachments) {
+    result.attachments = body.attachments.map((a) => ({
+      id: a.id,
+      filename: a.filename,
+      ...a.title != null && { title: a.title },
+      ...a.description != null && { description: a.description },
+      ...a.flags != null && { flags: a.flags }
+    }));
+  } else if (body.files?.length) {
+    result.attachments = body.files.map((f, i) => ({
+      id: i,
+      filename: f.filename ?? f.name
+    }));
+  }
+  return result;
+}
+var import_builders;
+var init_messageUtils = __esm({
+  "src/util/messageUtils.ts"() {
+    "use strict";
+    import_builders = require("@fluxerjs/builders");
+  }
+});
+
 // src/client/MessageManager.ts
 var MessageManager;
 var init_MessageManager = __esm({
@@ -33,7 +99,8 @@ var init_MessageManager = __esm({
       /**
        * Fetch a message by ID from this channel.
        * @param messageId - Snowflake of the message
-       * @returns The message, or null if not found
+       * @returns The message
+       * @throws FluxerError with MESSAGE_NOT_FOUND if the message does not exist
        */
       async fetch(messageId) {
         return this.client.channels.fetchMessage(this.channelId, messageId);
@@ -42,6 +109,118 @@ var init_MessageManager = __esm({
   }
 });
 
+// src/util/Events.ts
+var Events;
+var init_Events = __esm({
+  "src/util/Events.ts"() {
+    "use strict";
+    Events = {
+      Ready: "ready",
+      MessageCreate: "messageCreate",
+      MessageUpdate: "messageUpdate",
+      MessageDelete: "messageDelete",
+      MessageDeleteBulk: "messageDeleteBulk",
+      MessageReactionAdd: "messageReactionAdd",
+      MessageReactionRemove: "messageReactionRemove",
+      MessageReactionRemoveAll: "messageReactionRemoveAll",
+      MessageReactionRemoveEmoji: "messageReactionRemoveEmoji",
+      InteractionCreate: "interactionCreate",
+      GuildCreate: "guildCreate",
+      GuildUpdate: "guildUpdate",
+      GuildDelete: "guildDelete",
+      GuildBanAdd: "guildBanAdd",
+      GuildBanRemove: "guildBanRemove",
+      GuildEmojisUpdate: "guildEmojisUpdate",
+      GuildStickersUpdate: "guildStickersUpdate",
+      GuildIntegrationsUpdate: "guildIntegrationsUpdate",
+      GuildMemberAdd: "guildMemberAdd",
+      GuildMemberUpdate: "guildMemberUpdate",
+      GuildMemberRemove: "guildMemberRemove",
+      GuildRoleCreate: "guildRoleCreate",
+      GuildRoleUpdate: "guildRoleUpdate",
+      GuildRoleDelete: "guildRoleDelete",
+      GuildScheduledEventCreate: "guildScheduledEventCreate",
+      GuildScheduledEventUpdate: "guildScheduledEventUpdate",
+      GuildScheduledEventDelete: "guildScheduledEventDelete",
+      ChannelCreate: "channelCreate",
+      ChannelUpdate: "channelUpdate",
+      ChannelDelete: "channelDelete",
+      ChannelPinsUpdate: "channelPinsUpdate",
+      InviteCreate: "inviteCreate",
+      InviteDelete: "inviteDelete",
+      TypingStart: "typingStart",
+      UserUpdate: "userUpdate",
+      PresenceUpdate: "presenceUpdate",
+      VoiceStateUpdate: "voiceStateUpdate",
+      VoiceServerUpdate: "voiceServerUpdate",
+      VoiceStatesSync: "voiceStatesSync",
+      WebhooksUpdate: "webhooksUpdate",
+      Resumed: "resumed",
+      Error: "error",
+      Debug: "debug"
+    };
+  }
+});
+
+// src/util/MessageCollector.ts
+var import_events, import_collection, MessageCollector;
+var init_MessageCollector = __esm({
+  "src/util/MessageCollector.ts"() {
+    "use strict";
+    import_events = require("events");
+    import_collection = require("@fluxerjs/collection");
+    init_Events();
+    MessageCollector = class extends import_events.EventEmitter {
+      client;
+      channelId;
+      options;
+      collected = new import_collection.Collection();
+      _timeout = null;
+      _ended = false;
+      _listener;
+      constructor(client, channelId, options = {}) {
+        super();
+        this.client = client;
+        this.channelId = channelId;
+        this.options = {
+          filter: options.filter ?? (() => true),
+          time: options.time ?? 0,
+          max: options.max ?? 0
+        };
+        this._listener = (message) => {
+          if (this._ended || message.channelId !== this.channelId) return;
+          if (!this.options.filter(message)) return;
+          this.collected.set(message.id, message);
+          this.emit("collect", message);
+          if (this.options.max > 0 && this.collected.size >= this.options.max) {
+            this.stop("limit");
+          }
+        };
+        this.client.on(Events.MessageCreate, this._listener);
+        if (this.options.time > 0) {
+          this._timeout = setTimeout(() => this.stop("time"), this.options.time);
+        }
+      }
+      stop(reason = "user") {
+        if (this._ended) return;
+        this._ended = true;
+        this.client.off(Events.MessageCreate, this._listener);
+        if (this._timeout) {
+          clearTimeout(this._timeout);
+          this._timeout = null;
+        }
+        this.emit("end", this.collected, reason);
+      }
+      on(event, listener) {
+        return super.on(event, listener);
+      }
+      emit(event, ...args) {
+        return super.emit(event, ...args);
+      }
+    };
+  }
+});
+
 // src/structures/Base.ts
 var Base;
 var init_Base = __esm({
@@ -52,84 +231,119 @@ var init_Base = __esm({
   }
 });
 
-// src/structures/Webhook.ts
-var Webhook_exports = {};
-__export(Webhook_exports, {
-  Webhook: () => Webhook
+// src/util/Constants.ts
+var CDN_URL;
+var init_Constants = __esm({
+  "src/util/Constants.ts"() {
+    "use strict";
+    CDN_URL = "https://fluxerusercontent.com";
+  }
 });
-var import_types, Webhook;
-var init_Webhook = __esm({
-  "src/structures/Webhook.ts"() {
+
+// src/util/cdn.ts
+function getExtension(hash, options) {
+  const ext = options?.extension ?? "png";
+  if (hash?.startsWith("a_")) return "gif";
+  return ext;
+}
+function appendSize(options) {
+  return options?.size ? `?size=${options.size}` : "";
+}
+function cdnAvatarURL(userId, avatarHash, options) {
+  if (!avatarHash) return null;
+  const ext = getExtension(avatarHash, options);
+  const size = appendSize(options);
+  return `${CDN_URL}/avatars/${userId}/${avatarHash}.${ext}${size}`;
+}
+function cdnDisplayAvatarURL(userId, avatarHash, options) {
+  return cdnAvatarURL(userId, avatarHash, options) ?? `${CDN_URL}/avatars/0/0.png`;
+}
+function cdnBannerURL(resourceId, bannerHash, options) {
+  if (!bannerHash) return null;
+  const ext = getExtension(bannerHash, options);
+  const size = appendSize(options);
+  return `${CDN_URL}/banners/${resourceId}/${bannerHash}.${ext}${size}`;
+}
+function cdnMemberAvatarURL(guildId, userId, avatarHash, options) {
+  if (!avatarHash) return null;
+  const ext = getExtension(avatarHash, options);
+  const size = appendSize(options);
+  return `${CDN_URL}/guilds/${guildId}/users/${userId}/avatars/${avatarHash}.${ext}${size}`;
+}
+function cdnMemberBannerURL(guildId, userId, bannerHash, options) {
+  if (!bannerHash) return null;
+  const ext = getExtension(bannerHash, options);
+  const size = appendSize(options);
+  return `${CDN_URL}/guilds/${guildId}/users/${userId}/banners/${bannerHash}.${ext}${size}`;
+}
+function cdnDefaultAvatarURL(discriminatorIndex) {
+  const index = discriminatorIndex != null ? discriminatorIndex % 5 : 0;
+  return `${CDN_URL}/avatars/0/${index}.png`;
+}
+var init_cdn = __esm({
+  "src/util/cdn.ts"() {
     "use strict";
-    init_Base();
-    import_types = require("@fluxerjs/types");
-    Webhook = class _Webhook extends Base {
+    init_Constants();
+  }
+});
+
+// src/util/ReactionCollector.ts
+var import_events2, import_collection2, ReactionCollector;
+var init_ReactionCollector = __esm({
+  "src/util/ReactionCollector.ts"() {
+    "use strict";
+    import_events2 = require("events");
+    import_collection2 = require("@fluxerjs/collection");
+    init_Events();
+    ReactionCollector = class extends import_events2.EventEmitter {
       client;
-      id;
-      guildId;
+      messageId;
       channelId;
-      name;
-      avatar;
-      /** Present only when webhook was created via createWebhook(); not returned when fetching. */
-      token;
-      /** @param data - API webhook from POST /channels/{id}/webhooks (has token) or GET /webhooks/{id} (no token) */
-      constructor(client, data) {
+      options;
+      collected = new import_collection2.Collection();
+      _timeout = null;
+      _ended = false;
+      _listener;
+      constructor(client, messageId, channelId, options = {}) {
         super();
         this.client = client;
-        this.id = data.id;
-        this.guildId = data.guild_id;
-        this.channelId = data.channel_id;
-        this.name = data.name ?? "Unknown";
-        this.avatar = data.avatar ?? null;
-        this.token = data.token ?? null;
-      }
-      /** Delete this webhook. Requires bot token with Manage Webhooks permission. */
-      async delete() {
-        await this.client.rest.delete(import_types.Routes.webhook(this.id), { auth: true });
+        this.messageId = messageId;
+        this.channelId = channelId;
+        this.options = {
+          filter: options.filter ?? (() => true),
+          time: options.time ?? 0,
+          max: options.max ?? 0
+        };
+        this._listener = (reaction, user, _msgId, chId, _emoji, userId) => {
+          if (this._ended || reaction.messageId !== this.messageId || chId !== this.channelId) return;
+          if (!this.options.filter(reaction, user)) return;
+          const key = `${userId}:${reaction.emoji.id ?? reaction.emoji.name}`;
+          this.collected.set(key, { reaction, user });
+          this.emit("collect", reaction, user);
+          if (this.options.max > 0 && this.collected.size >= this.options.max) {
+            this.stop("limit");
+          }
+        };
+        this.client.on(Events.MessageReactionAdd, this._listener);
+        if (this.options.time > 0) {
+          this._timeout = setTimeout(() => this.stop("time"), this.options.time);
+        }
       }
-      /**
-       * Send a message via this webhook. Requires the webhook token (only present when created, not when fetched).
-       * @throws Error if token is not available
-       */
-      async send(options) {
-        if (!this.token) {
-          throw new Error(
-            "Webhook token is required to send. The token is only returned when creating a webhook; fetched webhooks cannot send."
-          );
+      stop(reason = "user") {
+        if (this._ended) return;
+        this._ended = true;
+        this.client.off(Events.MessageReactionAdd, this._listener);
+        if (this._timeout) {
+          clearTimeout(this._timeout);
+          this._timeout = null;
         }
-        const body = typeof options === "string" ? { content: options } : options;
-        await this.client.rest.post(import_types.Routes.webhookExecute(this.id, this.token), {
-          body,
-          auth: false
-        });
+        this.emit("end", this.collected, reason);
       }
-      /**
-       * Fetch a webhook by ID using bot auth.
-       * @param client - The client instance
-       * @param webhookId - The webhook ID
-       * @returns Webhook without token (cannot send)
-       */
-      static async fetch(client, webhookId) {
-        const data = await client.rest.get(import_types.Routes.webhook(webhookId));
-        return new _Webhook(client, data);
+      on(event, listener) {
+        return super.on(event, listener);
       }
-      /**
-       * Create a Webhook instance from an ID and token (e.g. from a stored webhook URL).
-       * @param client - The client instance
-       * @param webhookId - The webhook ID
-       * @param token - The webhook token (from createWebhook or stored)
-       * @param options - Optional channelId, guildId, name for display
-       */
-      static fromToken(client, webhookId, token, options) {
-        return new _Webhook(client, {
-          id: webhookId,
-          guild_id: options?.guildId ?? "",
-          channel_id: options?.channelId ?? "",
-          name: options?.name ?? "Webhook",
-          avatar: null,
-          token,
-          user: { id: "", username: "webhook", discriminator: "0" }
-        });
+      emit(event, ...args) {
+        return super.emit(event, ...args);
       }
     };
   }
@@ -140,14 +354,16 @@ var Message_exports = {};
 __export(Message_exports, {
   Message: () => Message
 });
-var import_collection, import_types2, import_builders, Message;
+var import_collection3, import_types, import_builders2, Message;
 var init_Message = __esm({
   "src/structures/Message.ts"() {
     "use strict";
     init_Base();
-    import_collection = require("@fluxerjs/collection");
-    import_types2 = require("@fluxerjs/types");
-    import_builders = require("@fluxerjs/builders");
+    import_collection3 = require("@fluxerjs/collection");
+    import_types = require("@fluxerjs/types");
+    import_builders2 = require("@fluxerjs/builders");
+    init_messageUtils();
+    init_ReactionCollector();
     Message = class _Message extends Base {
       client;
       id;
@@ -159,6 +375,25 @@ var init_Message = __esm({
       editedAt;
       pinned;
       attachments;
+      type;
+      flags;
+      mentionEveryone;
+      tts;
+      embeds;
+      stickers;
+      reactions;
+      messageReference;
+      messageSnapshots;
+      call;
+      referencedMessage;
+      /** Webhook ID if this message was sent via webhook. Null otherwise. */
+      webhookId;
+      /** Users mentioned in this message. */
+      mentions;
+      /** Role IDs mentioned in this message. */
+      mentionRoles;
+      /** Client-side nonce for acknowledgment. Null if not provided. */
+      nonce;
       /** Channel where this message was sent. Resolved from cache; null if not cached (e.g. DM channel not in cache). */
       get channel() {
         return this.client.channels.get(this.channelId) ?? null;
@@ -179,19 +414,37 @@ var init_Message = __esm({
         this.createdAt = new Date(data.timestamp);
         this.editedAt = data.edited_timestamp ? new Date(data.edited_timestamp) : null;
         this.pinned = data.pinned;
-        this.attachments = new import_collection.Collection();
+        this.attachments = new import_collection3.Collection();
         for (const a of data.attachments ?? []) this.attachments.set(a.id, a);
+        this.type = data.type ?? import_types.MessageType.Default;
+        this.flags = data.flags ?? 0;
+        this.mentionEveryone = data.mention_everyone ?? false;
+        this.tts = data.tts ?? false;
+        this.embeds = data.embeds ?? [];
+        this.stickers = data.stickers ?? [];
+        this.reactions = data.reactions ?? [];
+        this.messageReference = data.message_reference ?? null;
+        this.messageSnapshots = data.message_snapshots ?? [];
+        this.call = data.call ?? null;
+        this.referencedMessage = data.referenced_message ? new _Message(client, data.referenced_message) : null;
+        this.webhookId = data.webhook_id ?? null;
+        this.mentions = (data.mentions ?? []).map((u) => client.getOrCreateUser(u));
+        this.mentionRoles = data.mention_roles ?? [];
+        this.nonce = data.nonce ?? null;
       }
       /**
        * Send a message to this channel without replying. Use when you want a standalone message.
-       * @param options - Text content or object with content and/or embeds
+       * @param options - Text content or object with content, embeds, and/or files
        * @example
        * await message.send('Pong!');
        * await message.send({ embeds: [embed.toJSON()] });
+       * await message.send({ content: 'File', files: [{ name: 'data.txt', data }] });
        */
       async send(options) {
-        const body = typeof options === "string" ? { content: options } : options;
-        const data = await this.client.rest.post(import_types2.Routes.channelMessages(this.channelId), { body });
+        const opts = typeof options === "string" ? { content: options } : options;
+        const body = buildSendBody(options);
+        const postOptions = opts.files?.length ? { body, files: opts.files } : { body };
+        const data = await this.client.rest.post(import_types.Routes.channelMessages(this.channelId), postOptions);
         return new _Message(this.client, data);
       }
       /**
@@ -207,25 +460,21 @@ var init_Message = __esm({
       }
       /**
        * Reply to this message.
-       * @param options - Text content or object with content and/or embeds
+       * @param options - Text content or object with content, embeds, and/or files
        */
       async reply(options) {
-        const body = typeof options === "string" ? {
-          content: options,
-          message_reference: {
-            channel_id: this.channelId,
-            message_id: this.id,
-            guild_id: this.guildId ?? void 0
-          }
-        } : {
-          ...options,
+        const opts = typeof options === "string" ? { content: options } : options;
+        const base = buildSendBody(options);
+        const body = {
+          ...base,
           message_reference: {
             channel_id: this.channelId,
             message_id: this.id,
             guild_id: this.guildId ?? void 0
           }
         };
-        const data = await this.client.rest.post(import_types2.Routes.channelMessages(this.channelId), { body });
+        const postOptions = opts.files?.length ? { body, files: opts.files } : { body };
+        const data = await this.client.rest.post(import_types.Routes.channelMessages(this.channelId), postOptions);
         return new _Message(this.client, data);
       }
       /**
@@ -236,27 +485,50 @@ var init_Message = __esm({
         const body = {};
         if (options.content !== void 0) body.content = options.content;
         if (options.embeds?.length) {
-          body.embeds = options.embeds.map((e) => e instanceof import_builders.EmbedBuilder ? e.toJSON() : e);
+          body.embeds = options.embeds.map((e) => e instanceof import_builders2.EmbedBuilder ? e.toJSON() : e);
         }
-        const data = await this.client.rest.patch(import_types2.Routes.channelMessage(this.channelId, this.id), {
+        const data = await this.client.rest.patch(import_types.Routes.channelMessage(this.channelId, this.id), {
           body
         });
         return new _Message(this.client, data);
       }
+      /**
+       * Create a reaction collector for this message.
+       * Collects reactions matching the filter until time expires or max is reached.
+       * @param options - Filter, time (ms), and max count
+       * @example
+       * const collector = message.createReactionCollector({ filter: (r, u) => u.id === userId, time: 10000 });
+       * collector.on('collect', (reaction, user) => console.log(user.username, 'reacted with', reaction.emoji.name));
+       * collector.on('end', (collected, reason) => { ... });
+       */
+      createReactionCollector(options) {
+        return new ReactionCollector(this.client, this.id, this.channelId, options);
+      }
       /**
        * Re-fetch this message from the API to get the latest content, embeds, reactions, etc.
        * Use when you have a stale Message (e.g. from an old event or cache) and need fresh data.
-       * @returns The updated message, or null if deleted or not found
+       * @returns The updated message
+       * @throws FluxerError with MESSAGE_NOT_FOUND if the message was deleted or does not exist
        * @example
        * const updated = await message.fetch();
-       * if (updated) console.log('Latest content:', updated.content);
+       * console.log('Latest content:', updated.content);
        */
       async fetch() {
         return this.client.channels.fetchMessage(this.channelId, this.id);
       }
       /** Delete this message. */
       async delete() {
-        await this.client.rest.delete(import_types2.Routes.channelMessage(this.channelId, this.id));
+        await this.client.rest.delete(import_types.Routes.channelMessage(this.channelId, this.id));
+      }
+      /** Pin this message to the channel. Requires Manage Messages permission. */
+      async pin() {
+        await this.client.rest.put(import_types.Routes.channelPinMessage(this.channelId, this.id));
+        this.pinned = true;
+      }
+      /** Unpin this message from the channel. Requires Manage Messages permission. */
+      async unpin() {
+        await this.client.rest.delete(import_types.Routes.channelPinMessage(this.channelId, this.id));
+        this.pinned = false;
       }
       /**
        * Format emoji for reaction API: unicode string or "name:id" for custom.
@@ -275,7 +547,7 @@ var init_Message = __esm({
        */
       async react(emoji) {
         const emojiStr = await this.resolveEmojiForReaction(emoji);
-        const route = `${import_types2.Routes.channelMessageReaction(this.channelId, this.id, emojiStr)}/@me`;
+        const route = `${import_types.Routes.channelMessageReaction(this.channelId, this.id, emojiStr)}/@me`;
         await this.client.rest.put(route);
       }
       /**
@@ -285,7 +557,7 @@ var init_Message = __esm({
        */
       async removeReaction(emoji, userId) {
         const emojiStr = await this.resolveEmojiForReaction(emoji);
-        const route = `${import_types2.Routes.channelMessageReaction(this.channelId, this.id, emojiStr)}/${userId ?? "@me"}`;
+        const route = `${import_types.Routes.channelMessageReaction(this.channelId, this.id, emojiStr)}/${userId ?? "@me"}`;
         await this.client.rest.delete(route);
       }
       /**
@@ -293,7 +565,7 @@ var init_Message = __esm({
        * Requires moderator permissions.
        */
       async removeAllReactions() {
-        await this.client.rest.delete(import_types2.Routes.channelMessageReactions(this.channelId, this.id));
+        await this.client.rest.delete(import_types.Routes.channelMessageReactions(this.channelId, this.id));
       }
       /**
        * Remove all reactions of a specific emoji from this message.
@@ -301,7 +573,235 @@ var init_Message = __esm({
        */
       async removeReactionEmoji(emoji) {
         const emojiStr = await this.resolveEmojiForReaction(emoji);
-        await this.client.rest.delete(import_types2.Routes.channelMessageReaction(this.channelId, this.id, emojiStr));
+        await this.client.rest.delete(import_types.Routes.channelMessageReaction(this.channelId, this.id, emojiStr));
+      }
+      /**
+       * Fetch users who reacted with the given emoji.
+       * @param emoji - Unicode emoji or custom `{ name, id }`
+       * @param options - limit (1–100), after (user ID for pagination)
+       * @returns Array of User objects
+       */
+      async fetchReactionUsers(emoji, options) {
+        const emojiStr = await this.resolveEmojiForReaction(emoji);
+        const params = new URLSearchParams();
+        if (options?.limit != null) params.set("limit", String(options.limit));
+        if (options?.after) params.set("after", options.after);
+        const qs = params.toString();
+        const route = import_types.Routes.channelMessageReaction(this.channelId, this.id, emojiStr) + (qs ? `?${qs}` : "");
+        const data = await this.client.rest.get(route);
+        const list = Array.isArray(data) ? data : data?.users ?? [];
+        return list.map((u) => this.client.getOrCreateUser(u));
+      }
+    };
+  }
+});
+
+// src/structures/Webhook.ts
+var Webhook_exports = {};
+__export(Webhook_exports, {
+  Webhook: () => Webhook
+});
+var import_types2, Webhook;
+var init_Webhook = __esm({
+  "src/structures/Webhook.ts"() {
+    "use strict";
+    init_Base();
+    import_types2 = require("@fluxerjs/types");
+    init_messageUtils();
+    init_cdn();
+    Webhook = class _Webhook extends Base {
+      client;
+      id;
+      guildId;
+      channelId;
+      name;
+      avatar;
+      /** Present only when webhook was created via createWebhook(); not returned when fetching. */
+      token;
+      /** User who created the webhook. */
+      user;
+      /** @param data - API webhook from POST /channels/{id}/webhooks (has token) or GET /webhooks/{id} (no token) */
+      constructor(client, data) {
+        super();
+        this.client = client;
+        this.id = data.id;
+        this.guildId = data.guild_id;
+        this.channelId = data.channel_id;
+        this.name = data.name ?? "Unknown";
+        this.avatar = data.avatar ?? null;
+        this.token = data.token ?? null;
+        this.user = client.getOrCreateUser(data.user);
+      }
+      /**
+       * Get the URL for this webhook's avatar.
+       * Returns null if the webhook has no custom avatar.
+       */
+      avatarURL(options) {
+        return cdnAvatarURL(this.id, this.avatar, options);
+      }
+      /** Delete this webhook. Requires bot token with Manage Webhooks permission. */
+      async delete() {
+        await this.client.rest.delete(import_types2.Routes.webhook(this.id), { auth: true });
+      }
+      /**
+       * Edit this webhook. With token: name and avatar only. Without token (bot auth): name, avatar, and channel_id.
+       * @param options - Fields to update (name, avatar, channel_id when using bot auth)
+       * @returns This webhook instance with updated fields
+       */
+      async edit(options) {
+        const body = {};
+        if (options.name !== void 0) body.name = options.name;
+        if (options.avatar !== void 0) body.avatar = options.avatar;
+        if ("channel_id" in options && options.channel_id !== void 0 && !this.token) {
+          body.channel_id = options.channel_id;
+        }
+        if (this.token) {
+          const data2 = await this.client.rest.patch(import_types2.Routes.webhookExecute(this.id, this.token), {
+            body,
+            auth: false
+          });
+          const w2 = data2;
+          this.name = w2.name ?? this.name;
+          this.avatar = w2.avatar ?? null;
+          return this;
+        }
+        const data = await this.client.rest.patch(import_types2.Routes.webhook(this.id), {
+          body,
+          auth: true
+        });
+        const w = data;
+        this.name = w.name ?? this.name;
+        this.avatar = w.avatar ?? null;
+        this.channelId = w.channel_id ?? this.channelId;
+        return this;
+      }
+      /**
+       * Send a message via this webhook. Requires the webhook token (only present when created, not when fetched).
+       * @param options - Text content or object with content, embeds, username, avatar_url, tts, files, attachments
+       * @param wait - If true, waits for the API and returns the created Message; otherwise returns void (204)
+       * @throws Error if token is not available
+       * @example
+       * await webhook.send('Hello!');
+       * await webhook.send({ embeds: [embed.toJSON()] });
+       * await webhook.send({ content: 'File attached', files: [{ name: 'data.txt', data: buffer }] });
+       * const msg = await webhook.send({ content: 'Hi' }, true);
+       */
+      async send(options, wait) {
+        if (!this.token) {
+          throw new Error(
+            "Webhook token is required to send. The token is only returned when creating a webhook; fetched webhooks cannot send."
+          );
+        }
+        const opts = typeof options === "string" ? { content: options } : options;
+        const body = buildSendBody(options);
+        if (opts.username !== void 0) body.username = opts.username;
+        if (opts.avatar_url !== void 0) body.avatar_url = opts.avatar_url;
+        if (opts.tts !== void 0) body.tts = opts.tts;
+        const route = import_types2.Routes.webhookExecute(this.id, this.token) + (wait ? "?wait=true" : "");
+        const postOptions = opts.files?.length ? { body, files: opts.files, auth: false } : { body, auth: false };
+        const data = await this.client.rest.post(
+          route,
+          postOptions
+        );
+        if (wait && data) {
+          const { Message: Message2 } = await Promise.resolve().then(() => (init_Message(), Message_exports));
+          return new Message2(this.client, data);
+        }
+        return void 0;
+      }
+      /**
+       * Fetch a webhook by ID using bot auth.
+       * @param client - The client instance
+       * @param webhookId - The webhook ID
+       * @returns Webhook without token (cannot send)
+       */
+      static async fetch(client, webhookId) {
+        const data = await client.rest.get(import_types2.Routes.webhook(webhookId));
+        return new _Webhook(client, data);
+      }
+      /**
+       * Create a Webhook instance from an ID and token (e.g. from a stored webhook URL).
+       * @param client - The client instance
+       * @param webhookId - The webhook ID
+       * @param token - The webhook token (from createWebhook or stored)
+       * @param options - Optional channelId, guildId, name for display
+       */
+      static fromToken(client, webhookId, token, options) {
+        return new _Webhook(client, {
+          id: webhookId,
+          guild_id: options?.guildId ?? "",
+          channel_id: options?.channelId ?? "",
+          name: options?.name ?? "Webhook",
+          avatar: null,
+          token,
+          user: { id: "", username: "webhook", discriminator: "0" }
+        });
+      }
+    };
+  }
+});
+
+// src/structures/Invite.ts
+var Invite_exports = {};
+__export(Invite_exports, {
+  Invite: () => Invite
+});
+var import_types3, Invite;
+var init_Invite = __esm({
+  "src/structures/Invite.ts"() {
+    "use strict";
+    init_Base();
+    import_types3 = require("@fluxerjs/types");
+    Invite = class extends Base {
+      client;
+      code;
+      type;
+      guild;
+      channel;
+      inviter;
+      memberCount;
+      presenceCount;
+      expiresAt;
+      temporary;
+      createdAt;
+      uses;
+      maxUses;
+      maxAge;
+      /** @param data - API invite from GET /invites/{code}, channel/guild invite list, or gateway INVITE_CREATE */
+      constructor(client, data) {
+        super();
+        this.client = client;
+        this.code = data.code;
+        this.type = data.type;
+        this.guild = data.guild;
+        this.channel = data.channel;
+        this.inviter = data.inviter ? client.getOrCreateUser(data.inviter) : null;
+        this.memberCount = data.member_count ?? null;
+        this.presenceCount = data.presence_count ?? null;
+        this.expiresAt = data.expires_at ?? null;
+        this.temporary = data.temporary ?? null;
+        this.createdAt = data.created_at ?? null;
+        this.uses = data.uses ?? null;
+        this.maxUses = data.max_uses ?? null;
+        this.maxAge = data.max_age ?? null;
+      }
+      /** Full invite URL (https://fluxer.gg/{code} or instance-specific). */
+      get url() {
+        return `https://fluxer.gg/${this.code}`;
+      }
+      /**
+       * Resolve the guild from cache if available.
+       * @returns The guild, or null if not cached
+       */
+      getGuild() {
+        return this.guild?.id ? this.client.guilds.get(this.guild.id) ?? null : null;
+      }
+      /**
+       * Delete this invite.
+       * Requires Manage Guild or Create Instant Invite permission.
+       */
+      async delete() {
+        await this.client.rest.delete(import_types3.Routes.invite(this.code), { auth: true });
       }
     };
   }
@@ -318,13 +818,16 @@ __export(Channel_exports, {
   TextChannel: () => TextChannel,
   VoiceChannel: () => VoiceChannel
 });
-var import_types3, Channel, GuildChannel, TextChannel, CategoryChannel, VoiceChannel, LinkChannel, DMChannel;
+var import_types4, import_util, Channel, GuildChannel, TextChannel, CategoryChannel, VoiceChannel, LinkChannel, DMChannel;
 var init_Channel = __esm({
   "src/structures/Channel.ts"() {
     "use strict";
     init_MessageManager();
+    init_MessageCollector();
     init_Base();
-    import_types3 = require("@fluxerjs/types");
+    init_messageUtils();
+    import_types4 = require("@fluxerjs/types");
+    import_util = require("@fluxerjs/util");
     Channel = class _Channel extends Base {
       /** Whether this channel has a send method (TextChannel, DMChannel). */
       isSendable() {
@@ -332,7 +835,7 @@ var init_Channel = __esm({
       }
       /** Whether this channel is a DM or Group DM. */
       isDM() {
-        return this.type === import_types3.ChannelType.DM || this.type === import_types3.ChannelType.GroupDM;
+        return this.type === import_types4.ChannelType.DM || this.type === import_types4.ChannelType.GroupDM;
       }
       /** Whether this channel is voice-based (VoiceChannel). */
       isVoice() {
@@ -345,12 +848,21 @@ var init_Channel = __esm({
       client;
       id;
       type;
+      /** Channel name. Guild channels and Group DMs have names; 1:1 DMs are typically null. */
+      name;
+      /** Channel icon hash (Group DMs). Null if none. */
+      icon;
+      /** ISO timestamp when the last message was pinned. Null if never pinned. */
+      lastPinTimestamp;
       /** @param data - API channel from GET /channels/{id} or GET /guilds/{id}/channels */
       constructor(client, data) {
         super();
         this.client = client;
         this.id = data.id;
         this.type = data.type;
+        this.name = data.name ?? null;
+        this.icon = data.icon ?? null;
+        this.lastPinTimestamp = data.last_pin_timestamp ?? null;
       }
       /**
        * Create the appropriate channel subclass from API data.
@@ -359,10 +871,10 @@ var init_Channel = __esm({
        */
       static from(client, data) {
         const type = data.type ?? 0;
-        if (type === import_types3.ChannelType.GuildText) return new TextChannel(client, data);
-        if (type === import_types3.ChannelType.GuildCategory) return new CategoryChannel(client, data);
-        if (type === import_types3.ChannelType.GuildVoice) return new VoiceChannel(client, data);
-        if (type === import_types3.ChannelType.GuildLink || type === import_types3.ChannelType.GuildLinkExtended)
+        if (type === import_types4.ChannelType.GuildText) return new TextChannel(client, data);
+        if (type === import_types4.ChannelType.GuildCategory) return new CategoryChannel(client, data);
+        if (type === import_types4.ChannelType.GuildVoice) return new VoiceChannel(client, data);
+        if (type === import_types4.ChannelType.GuildLink || type === import_types4.ChannelType.GuildLinkExtended)
           return new LinkChannel(client, data);
         return new GuildChannel(client, data);
       }
@@ -372,22 +884,41 @@ var init_Channel = __esm({
        */
       static fromOrCreate(client, data) {
         const type = data.type ?? 0;
-        if (type === import_types3.ChannelType.DM || type === import_types3.ChannelType.GroupDM)
+        if (type === import_types4.ChannelType.DM || type === import_types4.ChannelType.GroupDM)
           return _Channel.createDM(client, data);
         return _Channel.from(client, data);
       }
+      /**
+       * Bulk delete messages. Requires Manage Messages permission.
+       * @param messageIds - Array of message IDs to delete (2–100)
+       */
+      async bulkDeleteMessages(messageIds) {
+        await this.client.rest.post(import_types4.Routes.channelBulkDelete(this.id), {
+          body: { message_ids: messageIds },
+          auth: true
+        });
+      }
+      /**
+       * Send a typing indicator to the channel. Lasts ~10 seconds.
+       */
+      async sendTyping() {
+        await this.client.rest.post(import_types4.Routes.channelTyping(this.id), { auth: true });
+      }
     };
     GuildChannel = class extends Channel {
       guildId;
       name;
       position;
       parentId;
+      /** Permission overwrites for roles and members. */
+      permissionOverwrites;
       constructor(client, data) {
         super(client, data);
         this.guildId = data.guild_id ?? "";
         this.name = data.name ?? null;
         this.position = data.position;
         this.parentId = data.parent_id ?? null;
+        this.permissionOverwrites = data.permission_overwrites ?? [];
       }
       /**
        * Create a webhook in this channel.
@@ -396,7 +927,7 @@ var init_Channel = __esm({
        */
       async createWebhook(options) {
         const { Webhook: Webhook2 } = await Promise.resolve().then(() => (init_Webhook(), Webhook_exports));
-        const data = await this.client.rest.post(import_types3.Routes.channelWebhooks(this.id), {
+        const data = await this.client.rest.post(import_types4.Routes.channelWebhooks(this.id), {
           body: options,
           auth: true
         });
@@ -408,10 +939,38 @@ var init_Channel = __esm({
        */
       async fetchWebhooks() {
         const { Webhook: Webhook2 } = await Promise.resolve().then(() => (init_Webhook(), Webhook_exports));
-        const data = await this.client.rest.get(import_types3.Routes.channelWebhooks(this.id));
+        const data = await this.client.rest.get(import_types4.Routes.channelWebhooks(this.id));
         const list = Array.isArray(data) ? data : Object.values(data ?? {});
         return list.map((w) => new Webhook2(this.client, w));
       }
+      /**
+       * Create an invite for this channel.
+       * @param options - max_uses (0–100), max_age (0–604800 seconds), unique, temporary
+       * Requires Create Instant Invite permission.
+       */
+      async createInvite(options) {
+        const { Invite: Invite2 } = await Promise.resolve().then(() => (init_Invite(), Invite_exports));
+        const body = {};
+        if (options?.max_uses != null) body.max_uses = options.max_uses;
+        if (options?.max_age != null) body.max_age = options.max_age;
+        if (options?.unique != null) body.unique = options.unique;
+        if (options?.temporary != null) body.temporary = options.temporary;
+        const data = await this.client.rest.post(import_types4.Routes.channelInvites(this.id), {
+          body: Object.keys(body).length ? body : void 0,
+          auth: true
+        });
+        return new Invite2(this.client, data);
+      }
+      /**
+       * Fetch invites for this channel.
+       * Requires Manage Channel permission.
+       */
+      async fetchInvites() {
+        const { Invite: Invite2 } = await Promise.resolve().then(() => (init_Invite(), Invite_exports));
+        const data = await this.client.rest.get(import_types4.Routes.channelInvites(this.id));
+        const list = Array.isArray(data) ? data : Object.values(data ?? {});
+        return list.map((i) => new Invite2(this.client, i));
+      }
     };
     TextChannel = class extends GuildChannel {
       topic;
@@ -427,18 +986,45 @@ var init_Channel = __esm({
       }
       /**
        * Send a message to this channel.
-       * @param options - Text content or object with `content` and/or `embeds`
+       * @param options - Text content or object with content, embeds, and/or files
        */
       async send(options) {
-        const body = typeof options === "string" ? { content: options } : options;
+        const opts = typeof options === "string" ? { content: options } : options;
+        const body = buildSendBody(options);
         const { Message: Message2 } = await Promise.resolve().then(() => (init_Message(), Message_exports));
-        const data = await this.client.rest.post(import_types3.Routes.channelMessages(this.id), { body });
+        const postOptions = opts.files?.length ? { body, files: opts.files } : { body };
+        const data = await this.client.rest.post(import_types4.Routes.channelMessages(this.id), postOptions);
         return new Message2(this.client, data);
       }
       /** Message manager for this channel. Use channel.messages.fetch(messageId). */
       get messages() {
         return new MessageManager(this.client, this.id);
       }
+      /**
+       * Create a message collector for this channel.
+       * Collects messages matching the filter until time expires or max is reached.
+       * @param options - Filter, time (ms), and max count
+       * @example
+       * const collector = channel.createMessageCollector({ filter: m => m.author.id === userId, time: 10000 });
+       * collector.on('collect', m => console.log(m.content));
+       * collector.on('end', (collected, reason) => { ... });
+       */
+      createMessageCollector(options) {
+        return new MessageCollector(this.client, this.id, options);
+      }
+      /**
+       * Fetch pinned messages in this channel.
+       * @returns Pinned messages
+       */
+      async fetchPinnedMessages() {
+        const { Message: Message2 } = await Promise.resolve().then(() => (init_Message(), Message_exports));
+        const data = await this.client.rest.get(import_types4.Routes.channelPins(this.id));
+        const list = Array.isArray(data) ? data : data?.items ?? [];
+        return list.map((item) => {
+          const msg = typeof item === "object" && item && "message" in item ? item.message : item;
+          return new Message2(this.client, msg);
+        });
+      }
       /**
        * Fetch a message by ID from this channel.
        * @param messageId - Snowflake of the message
@@ -446,6 +1032,10 @@ var init_Channel = __esm({
        * @deprecated Use channel.messages.fetch(messageId) instead.
        */
       async fetchMessage(messageId) {
+        (0, import_util.emitDeprecationWarning)(
+          "Channel.fetchMessage()",
+          "Use channel.messages.fetch(messageId) instead."
+        );
         return this.client.channels.fetchMessage(this.id, messageId);
       }
     };
@@ -471,24 +1061,57 @@ var init_Channel = __esm({
     };
     DMChannel = class extends Channel {
       lastMessageId;
+      /** Group DM creator ID. Null for 1:1 DMs. */
+      ownerId;
+      /** Group DM recipients as User objects. Empty for 1:1 DMs. */
+      recipients;
+      /** Group DM member display names (userId -> nickname). */
+      nicks;
       constructor(client, data) {
         super(client, data);
         this.lastMessageId = data.last_message_id ?? null;
+        this.ownerId = data.owner_id ?? null;
+        this.recipients = (data.recipients ?? []).map(
+          (u) => client.getOrCreateUser(u)
+        );
+        this.nicks = data.nicks ?? {};
       }
       /**
        * Send a message to this DM channel.
-       * @param options - Text content or object with `content` and/or `embeds`
+       * @param options - Text content or object with content, embeds, and/or files
        */
       async send(options) {
-        const body = typeof options === "string" ? { content: options } : options;
+        const opts = typeof options === "string" ? { content: options } : options;
+        const body = buildSendBody(options);
         const { Message: Message2 } = await Promise.resolve().then(() => (init_Message(), Message_exports));
-        const data = await this.client.rest.post(import_types3.Routes.channelMessages(this.id), { body });
+        const postOptions = opts.files?.length ? { body, files: opts.files } : { body };
+        const data = await this.client.rest.post(import_types4.Routes.channelMessages(this.id), postOptions);
         return new Message2(this.client, data);
       }
       /** Message manager for this channel. Use channel.messages.fetch(messageId). */
       get messages() {
         return new MessageManager(this.client, this.id);
       }
+      /**
+       * Create a message collector for this DM channel.
+       * @param options - Filter, time (ms), and max count
+       */
+      createMessageCollector(options) {
+        return new MessageCollector(this.client, this.id, options);
+      }
+      /**
+       * Fetch pinned messages in this DM channel.
+       * @returns Pinned messages
+       */
+      async fetchPinnedMessages() {
+        const { Message: Message2 } = await Promise.resolve().then(() => (init_Message(), Message_exports));
+        const data = await this.client.rest.get(import_types4.Routes.channelPins(this.id));
+        const list = Array.isArray(data) ? data : data?.items ?? [];
+        return list.map((item) => {
+          const msg = typeof item === "object" && item && "message" in item ? item.message : item;
+          return new Message2(this.client, msg);
+        });
+      }
       /**
        * Fetch a message by ID from this DM channel.
        * @param messageId - Snowflake of the message
@@ -496,23 +1119,57 @@ var init_Channel = __esm({
        * @deprecated Use channel.messages.fetch(messageId) instead.
        */
       async fetchMessage(messageId) {
+        (0, import_util.emitDeprecationWarning)(
+          "Channel.fetchMessage()",
+          "Use channel.messages.fetch(messageId) instead."
+        );
         return this.client.channels.fetchMessage(this.id, messageId);
       }
     };
   }
 });
 
+// src/util/permissions.ts
+function computePermissions(basePermissions, overwrites, memberRoles, memberId, isOwner) {
+  if (isOwner) return import_util3.ALL_PERMISSIONS_BIGINT;
+  let perms = basePermissions;
+  for (const overwrite of overwrites ?? []) {
+    const applies = overwrite.type === import_types6.OverwriteType.Role && memberRoles.includes(overwrite.id) || overwrite.type === import_types6.OverwriteType.Member && overwrite.id === memberId;
+    if (!applies) continue;
+    const allow = BigInt(overwrite.allow || "0");
+    const deny = BigInt(overwrite.deny || "0");
+    perms = perms & ~deny | allow;
+  }
+  return perms;
+}
+function hasPermission(bitfield, permission) {
+  const Administrator = 1n << 3n;
+  if ((bitfield & Administrator) !== 0n) return true;
+  return (bitfield & permission) === permission;
+}
+var import_types6, import_util3;
+var init_permissions = __esm({
+  "src/util/permissions.ts"() {
+    "use strict";
+    import_types6 = require("@fluxerjs/types");
+    import_util3 = require("@fluxerjs/util");
+  }
+});
+
 // src/structures/GuildMember.ts
 var GuildMember_exports = {};
 __export(GuildMember_exports, {
   GuildMember: () => GuildMember
 });
-var import_types5, GuildMember;
+var import_util4, import_types7, GuildMember;
 var init_GuildMember = __esm({
   "src/structures/GuildMember.ts"() {
     "use strict";
     init_Base();
-    import_types5 = require("@fluxerjs/types");
+    import_util4 = require("@fluxerjs/util");
+    import_types7 = require("@fluxerjs/types");
+    init_cdn();
+    init_permissions();
     GuildMember = class extends Base {
       client;
       id;
@@ -522,6 +1179,12 @@ var init_GuildMember = __esm({
       roles;
       joinedAt;
       communicationDisabledUntil;
+      mute;
+      deaf;
+      avatar;
+      banner;
+      accentColor;
+      profileFlags;
       /** @param data - API guild member from GET /guilds/{id}/members or GET /guilds/{id}/members/{user_id} */
       constructor(client, data, guild) {
         super();
@@ -533,18 +1196,45 @@ var init_GuildMember = __esm({
         this.roles = data.roles ?? [];
         this.joinedAt = new Date(data.joined_at);
         this.communicationDisabledUntil = data.communication_disabled_until ? new Date(data.communication_disabled_until) : null;
+        this.mute = data.mute ?? false;
+        this.deaf = data.deaf ?? false;
+        this.avatar = data.avatar ?? null;
+        this.banner = data.banner ?? null;
+        this.accentColor = data.accent_color ?? null;
+        this.profileFlags = data.profile_flags ?? null;
       }
       /** Nickname, or global name, or username. */
       get displayName() {
         return this.nick ?? this.user.globalName ?? this.user.username;
       }
+      /**
+       * Get the guild-specific avatar URL for this member.
+       * Returns null if the member has no guild avatar (use displayAvatarURL for fallback).
+       */
+      avatarURL(options) {
+        return cdnMemberAvatarURL(this.guild.id, this.id, this.avatar, options);
+      }
+      /**
+       * Get the avatar URL to display for this member.
+       * Uses guild-specific avatar if set, otherwise falls back to the user's avatar.
+       */
+      displayAvatarURL(options) {
+        return this.avatarURL(options) ?? this.user.displayAvatarURL(options);
+      }
+      /**
+       * Get the guild-specific banner URL for this member.
+       * Returns null if the member has no guild banner.
+       */
+      bannerURL(options) {
+        return cdnMemberBannerURL(this.guild.id, this.id, this.banner, options);
+      }
       /**
        * Add a role to this member.
        * @param roleId - The role ID to add
        * Requires Manage Roles permission.
        */
       async addRole(roleId) {
-        await this.client.rest.put(import_types5.Routes.guildMemberRole(this.guild.id, this.id, roleId));
+        await this.client.rest.put(import_types7.Routes.guildMemberRole(this.guild.id, this.id, roleId));
       }
       /**
        * Remove a role from this member.
@@ -552,7 +1242,67 @@ var init_GuildMember = __esm({
        * Requires Manage Roles permission.
        */
       async removeRole(roleId) {
-        await this.client.rest.delete(import_types5.Routes.guildMemberRole(this.guild.id, this.id, roleId));
+        await this.client.rest.delete(import_types7.Routes.guildMemberRole(this.guild.id, this.id, roleId));
+      }
+      /**
+       * Get the member's guild-level permissions (from roles only, no channel overwrites).
+       * Use this for server-wide permission checks (e.g. ban, kick, manage roles).
+       * @returns Object with has(permission) to check specific permissions
+       * @example
+       * const perms = member.permissions;
+       * if (perms.has(PermissionFlags.BanMembers)) { ... }
+       */
+      get permissions() {
+        const base = this._computeBasePermissions();
+        const ownerId = this.guild.ownerId;
+        const isOwner = ownerId != null && ownerId !== "" && String(ownerId) === String(this.id);
+        const perms = computePermissions(base, [], [], this.id, isOwner);
+        return {
+          has(permission) {
+            const perm = typeof permission === "number" ? permission : import_util4.PermissionFlagsMap[String(permission)];
+            if (perm === void 0) return false;
+            return hasPermission(perms, BigInt(perm));
+          }
+        };
+      }
+      /**
+       * Compute the member's effective permissions in a guild channel.
+       * Applies role permissions and channel overwrites.
+       * @param channel - The guild channel to check permissions for
+       * @returns Object with has(permission) to check specific permissions
+       * @example
+       * const perms = member.permissionsIn(channel);
+       * if (perms.has(PermissionFlags.SendMessages)) { ... }
+       */
+      permissionsIn(channel) {
+        const base = this._computeBasePermissions();
+        const ownerId = this.guild.ownerId;
+        const isOwner = ownerId != null && ownerId !== "" && String(ownerId) === String(this.id);
+        const perms = computePermissions(
+          base,
+          channel.permissionOverwrites,
+          this.roles,
+          this.id,
+          isOwner
+        );
+        return {
+          has(permission) {
+            const perm = typeof permission === "number" ? permission : import_util4.PermissionFlagsMap[String(permission)];
+            if (perm === void 0) return false;
+            return hasPermission(perms, BigInt(perm));
+          }
+        };
+      }
+      _computeBasePermissions() {
+        let base = 0n;
+        const everyone = this.guild.roles.get(this.guild.id);
+        if (everyone) base |= BigInt(everyone.permissions);
+        for (const roleId of this.roles) {
+          if (roleId === this.guild.id) continue;
+          const role = this.guild.roles.get(roleId);
+          if (role) base |= BigInt(role.permissions);
+        }
+        return base;
       }
     };
   }
@@ -563,11 +1313,12 @@ var Role_exports = {};
 __export(Role_exports, {
   Role: () => Role
 });
-var Role;
+var import_util5, Role;
 var init_Role = __esm({
   "src/structures/Role.ts"() {
     "use strict";
     init_Base();
+    import_util5 = require("@fluxerjs/util");
     Role = class extends Base {
       client;
       id;
@@ -579,6 +1330,8 @@ var init_Role = __esm({
       hoist;
       mentionable;
       unicodeEmoji;
+      /** Separately sorted position for hoisted roles. Null if not set. */
+      hoistPosition;
       /** @param client - The client instance */
       /** @param data - API role from GET /guilds/{id}/roles or gateway role events */
       /** @param guildId - The guild this role belongs to */
@@ -594,21 +1347,71 @@ var init_Role = __esm({
         this.hoist = !!data.hoist;
         this.mentionable = !!data.mentionable;
         this.unicodeEmoji = data.unicode_emoji ?? null;
+        this.hoistPosition = data.hoist_position ?? null;
       }
       /** Returns a mention string (e.g. `<@&123456>`). */
       toString() {
         return `<@&${this.id}>`;
       }
+      /**
+       * Check if this role has a permission. Administrator grants all permissions.
+       * @param permission - Permission flag, name, or resolvable
+       * @returns true if the role has the permission
+       * @example
+       * if (role.has(PermissionFlags.BanMembers)) { ... }
+       * if (role.has('ManageChannels')) { ... }
+       */
+      has(permission) {
+        const perm = typeof permission === "number" ? permission : import_util5.PermissionFlags[permission];
+        if (perm === void 0) return false;
+        const permNum = Number(perm);
+        const rolePerms = BigInt(this.permissions);
+        const permBig = BigInt(permNum);
+        if (permBig < 0) return false;
+        if ((rolePerms & BigInt(import_util5.PermissionFlags.Administrator)) !== 0n) return true;
+        return (rolePerms & permBig) === permBig;
+      }
     };
   }
 });
 
-// src/util/Constants.ts
-var CDN_URL;
-var init_Constants = __esm({
-  "src/util/Constants.ts"() {
+// src/structures/GuildBan.ts
+var GuildBan_exports = {};
+__export(GuildBan_exports, {
+  GuildBan: () => GuildBan
+});
+var import_types8, GuildBan;
+var init_GuildBan = __esm({
+  "src/structures/GuildBan.ts"() {
     "use strict";
-    CDN_URL = "https://fluxerusercontent.com";
+    init_Base();
+    import_types8 = require("@fluxerjs/types");
+    GuildBan = class extends Base {
+      client;
+      guildId;
+      user;
+      reason;
+      /** ISO timestamp when a temporary ban expires. Null for permanent bans. */
+      expiresAt;
+      /** @param data - API ban from GET /guilds/{id}/bans or gateway GUILD_BAN_ADD */
+      constructor(client, data, guildId) {
+        super();
+        this.client = client;
+        this.guildId = data.guild_id ?? guildId;
+        this.user = client.getOrCreateUser(data.user);
+        this.reason = data.reason ?? null;
+        this.expiresAt = data.expires_at ?? null;
+      }
+      /**
+       * Remove this ban (unban the user).
+       * Requires Ban Members permission.
+       */
+      async unban() {
+        await this.client.rest.delete(import_types8.Routes.guildBan(this.guildId, this.user.id), {
+          auth: true
+        });
+      }
+    };
   }
 });
 
@@ -617,17 +1420,20 @@ var Guild_exports = {};
 __export(Guild_exports, {
   Guild: () => Guild
 });
-var import_util, import_collection3, import_types6, Guild;
+var import_util6, import_rest2, import_collection5, import_types9, Guild;
 var init_Guild = __esm({
   "src/structures/Guild.ts"() {
     "use strict";
-    import_util = require("@fluxerjs/util");
+    import_util6 = require("@fluxerjs/util");
+    import_rest2 = require("@fluxerjs/rest");
     init_Base();
-    import_collection3 = require("@fluxerjs/collection");
+    init_FluxerError();
+    init_ErrorCodes();
+    import_collection5 = require("@fluxerjs/collection");
     init_GuildMember();
     init_Role();
     init_Constants();
-    import_types6 = require("@fluxerjs/types");
+    import_types9 = require("@fluxerjs/types");
     Guild = class extends Base {
       client;
       id;
@@ -635,9 +1441,36 @@ var init_Guild = __esm({
       icon;
       banner;
       ownerId;
-      members = new import_collection3.Collection();
-      channels = new import_collection3.Collection();
-      roles = new import_collection3.Collection();
+      /** Invite splash image hash. Null if none. */
+      splash;
+      /** Custom vanity URL code (e.g. fluxer.gg/code). Null if none. */
+      vanityURLCode;
+      /** Enabled guild features. */
+      features;
+      verificationLevel;
+      defaultMessageNotifications;
+      explicitContentFilter;
+      /** AFK voice channel ID. Null if none. */
+      afkChannelId;
+      /** AFK timeout in seconds. */
+      afkTimeout;
+      /** System messages channel ID. Null if none. */
+      systemChannelId;
+      /** Rules/guidelines channel ID. Null if none. */
+      rulesChannelId;
+      nsfwLevel;
+      mfaLevel;
+      /** Banner image width. Optional. */
+      bannerWidth;
+      /** Banner image height. Optional. */
+      bannerHeight;
+      /** Splash image width. Optional. */
+      splashWidth;
+      /** Splash image height. Optional. */
+      splashHeight;
+      members = new import_collection5.Collection();
+      channels = new import_collection5.Collection();
+      roles = new import_collection5.Collection();
       /** @param data - API guild from GET /guilds/{id} or gateway GUILD_CREATE */
       constructor(client, data) {
         super();
@@ -646,7 +1479,23 @@ var init_Guild = __esm({
         this.name = data.name;
         this.icon = data.icon ?? null;
         this.banner = data.banner ?? null;
-        this.ownerId = data.owner_id;
+        this.ownerId = data.owner_id ?? data.ownerId ?? "";
+        this.splash = data.splash ?? null;
+        this.vanityURLCode = data.vanity_url_code ?? null;
+        this.features = data.features ?? [];
+        this.verificationLevel = data.verification_level ?? 0;
+        this.defaultMessageNotifications = data.default_message_notifications ?? 0;
+        this.explicitContentFilter = data.explicit_content_filter ?? 0;
+        this.afkChannelId = data.afk_channel_id ?? null;
+        this.afkTimeout = data.afk_timeout ?? 0;
+        this.systemChannelId = data.system_channel_id ?? null;
+        this.rulesChannelId = data.rules_channel_id ?? null;
+        this.nsfwLevel = data.nsfw_level ?? 0;
+        this.mfaLevel = data.mfa_level ?? 0;
+        this.bannerWidth = data.banner_width ?? null;
+        this.bannerHeight = data.banner_height ?? null;
+        this.splashWidth = data.splash_width ?? null;
+        this.splashHeight = data.splash_height ?? null;
         for (const r of data.roles ?? []) {
           this.roles.set(r.id, new Role(client, r, this.id));
         }
@@ -663,6 +1512,12 @@ var init_Guild = __esm({
         const size = options?.size ? `?size=${options.size}` : "";
         return `${CDN_URL}/banners/${this.id}/${this.banner}.png${size}`;
       }
+      /** Get the guild splash (invite background) URL, or null if no splash. */
+      splashURL(options) {
+        if (!this.splash) return null;
+        const size = options?.size ? `?size=${options.size}` : "";
+        return `${CDN_URL}/splashes/${this.id}/${this.splash}.png${size}`;
+      }
       /**
        * Add a role to a member by user ID. Does not require fetching the member first.
        * @param userId - The user ID of the member
@@ -670,7 +1525,7 @@ var init_Guild = __esm({
        * Requires Manage Roles permission.
        */
       async addRoleToMember(userId, roleId) {
-        await this.client.rest.put(import_types6.Routes.guildMemberRole(this.id, userId, roleId));
+        await this.client.rest.put(import_types9.Routes.guildMemberRole(this.id, userId, roleId));
       }
       /**
        * Remove a role from a member by user ID. Does not require fetching the member first.
@@ -679,7 +1534,7 @@ var init_Guild = __esm({
        * Requires Manage Roles permission.
        */
       async removeRoleFromMember(userId, roleId) {
-        await this.client.rest.delete(import_types6.Routes.guildMemberRole(this.id, userId, roleId));
+        await this.client.rest.delete(import_types9.Routes.guildMemberRole(this.id, userId, roleId));
       }
       /**
        * Resolve a role ID from an argument (role mention, raw ID, or name).
@@ -688,14 +1543,14 @@ var init_Guild = __esm({
        * @returns The role ID, or null if not found
        */
       async resolveRoleId(arg) {
-        const parsed = (0, import_util.parseRoleMention)(arg);
+        const parsed = (0, import_util6.parseRoleMention)(arg);
         if (parsed) return parsed;
         if (/^\d{17,19}$/.test(arg.trim())) return arg.trim();
         const cached = this.roles.find(
           (r) => !!(r.name && r.name.toLowerCase() === arg.trim().toLowerCase())
         );
         if (cached) return cached.id;
-        const roles = await this.client.rest.get(import_types6.Routes.guildRoles(this.id));
+        const roles = await this.client.rest.get(import_types9.Routes.guildRoles(this.id));
         const list = Array.isArray(roles) ? roles : Object.values(roles ?? {});
         const role = list.find((r) => !!(r.name && r.name.toLowerCase() === arg.trim().toLowerCase()));
         if (role) {
@@ -704,39 +1559,158 @@ var init_Guild = __esm({
         }
         return null;
       }
+      /**
+       * Ban a user from this guild.
+       * @param userId - The user ID to ban
+       * @param options - Optional reason, delete_message_days (0–7), and ban_duration_seconds (temporary ban).
+       *   ban_duration_seconds: 0 = permanent, or use 3600, 43200, 86400, 259200, 432000, 604800, 1209600, 2592000.
+       * Requires Ban Members permission.
+       */
+      async ban(userId, options) {
+        const body = {};
+        if (options?.reason) body.reason = options.reason;
+        if (options?.delete_message_days != null)
+          body.delete_message_days = options.delete_message_days;
+        if (options?.ban_duration_seconds != null)
+          body.ban_duration_seconds = options.ban_duration_seconds;
+        await this.client.rest.put(import_types9.Routes.guildBan(this.id, userId), {
+          body: Object.keys(body).length ? body : void 0,
+          auth: true
+        });
+      }
+      /**
+       * Fetch guild bans. Requires Ban Members permission.
+       * @returns List of GuildBan objects
+       */
+      async fetchBans() {
+        const { GuildBan: GuildBan2 } = await Promise.resolve().then(() => (init_GuildBan(), GuildBan_exports));
+        const data = await this.client.rest.get(import_types9.Routes.guildBans(this.id));
+        const list = Array.isArray(data) ? data : data?.bans ?? [];
+        return list.map((b) => new GuildBan2(this.client, { ...b, guild_id: this.id }, this.id));
+      }
+      /**
+       * Remove a ban (unban a user).
+       * @param userId - The user ID to unban
+       * Requires Ban Members permission.
+       */
+      async unban(userId) {
+        await this.client.rest.delete(import_types9.Routes.guildBan(this.id, userId), { auth: true });
+      }
+      /**
+       * Kick a member from this guild.
+       * @param userId - The user ID to kick
+       * Requires Kick Members permission.
+       */
+      async kick(userId) {
+        await this.client.rest.delete(import_types9.Routes.guildMember(this.id, userId), { auth: true });
+      }
       /**
        * Fetch a guild member by user ID.
        * @param userId - The user ID of the member to fetch
-       * @returns The guild member, or null if not found
+       * @returns The guild member
+       * @throws FluxerError with MEMBER_NOT_FOUND if user is not in the guild (404)
+       * @throws FluxerError with cause for permission denied (403) or other REST errors
        */
       async fetchMember(userId) {
         try {
           const data = await this.client.rest.get(
-            import_types6.Routes.guildMember(this.id, userId)
+            import_types9.Routes.guildMember(this.id, userId)
           );
-          return new GuildMember(this.client, { ...data, guild_id: this.id }, this);
-        } catch {
-          return null;
+          const member = new GuildMember(this.client, { ...data, guild_id: this.id }, this);
+          this.members.set(member.id, member);
+          return member;
+        } catch (err) {
+          const statusCode = err instanceof import_rest2.FluxerAPIError ? err.statusCode : err?.statusCode;
+          if (statusCode === 404) {
+            throw new FluxerError(`Member ${userId} not found in guild`, {
+              code: ErrorCodes.MemberNotFound,
+              cause: err
+            });
+          }
+          throw err instanceof FluxerError ? err : new FluxerError("Failed to fetch guild member", { cause: err });
         }
       }
+      /**
+       * Fetch guild audit logs. Requires View Audit Log permission.
+       * @param options - Optional limit, before, after, user_id, action_type for filtering
+       */
+      async fetchAuditLogs(options) {
+        const params = new URLSearchParams();
+        if (options?.limit != null) params.set("limit", String(options.limit));
+        if (options?.before) params.set("before", options.before);
+        if (options?.after) params.set("after", options.after);
+        if (options?.userId) params.set("user_id", options.userId);
+        if (options?.actionType != null) params.set("action_type", String(options.actionType));
+        const qs = params.toString();
+        const url = import_types9.Routes.guildAuditLogs(this.id) + (qs ? `?${qs}` : "");
+        return this.client.rest.get(url);
+      }
       /** Fetch all webhooks in this guild. Returned webhooks do not include the token (cannot send). */
       async fetchWebhooks() {
         const { Webhook: Webhook2 } = await Promise.resolve().then(() => (init_Webhook(), Webhook_exports));
-        const data = await this.client.rest.get(import_types6.Routes.guildWebhooks(this.id));
+        const data = await this.client.rest.get(import_types9.Routes.guildWebhooks(this.id));
         const list = Array.isArray(data) ? data : Object.values(data ?? {});
         return list.map((w) => new Webhook2(this.client, w));
       }
+      /**
+       * Create a channel in this guild.
+       * @param data - Channel data: type (0=text, 2=voice, 4=category, 5=link), name, and optional parent_id, topic, bitrate, user_limit, nsfw, permission_overwrites
+       * Requires Manage Channels permission.
+       */
+      async createChannel(data) {
+        const { Channel: Channel2 } = await Promise.resolve().then(() => (init_Channel(), Channel_exports));
+        const created = await this.client.rest.post(import_types9.Routes.guildChannels(this.id), {
+          body: data,
+          auth: true
+        });
+        const channel = Channel2.from(this.client, created);
+        if (channel) {
+          this.client.channels.set(channel.id, channel);
+          this.channels.set(channel.id, channel);
+        }
+        return channel;
+      }
+      /**
+       * Fetch all channels in this guild.
+       * @returns Array of GuildChannel objects (cached in guild.channels and client.channels)
+       */
+      async fetchChannels() {
+        const { Channel: Channel2 } = await Promise.resolve().then(() => (init_Channel(), Channel_exports));
+        const data = await this.client.rest.get(import_types9.Routes.guildChannels(this.id));
+        const list = Array.isArray(data) ? data : Object.values(data ?? {});
+        const channels = [];
+        for (const ch of list) {
+          const channel = Channel2.from(this.client, ch);
+          if (channel) {
+            this.client.channels.set(channel.id, channel);
+            this.channels.set(channel.id, channel);
+            channels.push(channel);
+          }
+        }
+        return channels;
+      }
+      /**
+       * Update channel positions.
+       * @param updates - Array of { id, position?, parent_id?, lock_permissions? }
+       * Requires Manage Channels permission.
+       */
+      async setChannelPositions(updates) {
+        await this.client.rest.patch(import_types9.Routes.guildChannels(this.id), {
+          body: updates,
+          auth: true
+        });
+      }
     };
   }
 });
 
 // src/structures/User.ts
-var import_types8, User;
+var import_types11, User;
 var init_User = __esm({
   "src/structures/User.ts"() {
     "use strict";
     init_Base();
-    import_types8 = require("@fluxerjs/types");
+    import_types11 = require("@fluxerjs/types");
     init_Constants();
     User = class extends Base {
       client;
@@ -746,6 +1720,14 @@ var init_User = __esm({
       globalName;
       avatar;
       bot;
+      /** RGB avatar color (e.g. 7577782). Null if not set. */
+      avatarColor;
+      /** Public flags bitfield. Null if not set. */
+      flags;
+      /** Whether this is an official system user. */
+      system;
+      /** Banner hash (from profile, member, or invite context). Null when not available. */
+      banner;
       /** @param data - API user from message author, GET /users/{id}, or GET /users/@me */
       constructor(client, data) {
         super();
@@ -756,6 +1738,10 @@ var init_User = __esm({
         this.globalName = data.global_name ?? null;
         this.avatar = data.avatar ?? null;
         this.bot = !!data.bot;
+        this.avatarColor = data.avatar_color ?? null;
+        this.flags = data.flags ?? data.public_flags ?? null;
+        this.system = !!data.system;
+        this.banner = data.banner ?? null;
       }
       /** Update mutable fields from fresh API data. Used by getOrCreateUser cache. */
       _patch(data) {
@@ -763,14 +1749,18 @@ var init_User = __esm({
         this.discriminator = data.discriminator;
         this.globalName = data.global_name ?? null;
         this.avatar = data.avatar ?? null;
+        if (data.avatar_color !== void 0) this.avatarColor = data.avatar_color;
+        if (data.flags !== void 0) this.flags = data.flags;
+        if (data.banner !== void 0) this.banner = data.banner;
       }
       /**
        * Get the URL for this user's avatar.
-       * @param options - Optional `size` and `extension` (default: `png`)
+       * Auto-detects animated avatars (hash starting with `a_`) and uses gif extension.
+       * @param options - Optional `size` and `extension` (default: png, or gif for animated)
        */
       avatarURL(options) {
         if (!this.avatar) return null;
-        const ext = options?.extension ?? "png";
+        const ext = this.avatar.startsWith("a_") ? "gif" : options?.extension ?? "png";
         const size = options?.size ? `?size=${options.size}` : "";
         return `${CDN_URL}/avatars/${this.id}/${this.avatar}.${ext}${size}`;
       }
@@ -778,6 +1768,16 @@ var init_User = __esm({
       displayAvatarURL(options) {
         return this.avatarURL(options) ?? `${CDN_URL}/avatars/0/0.png`;
       }
+      /**
+       * Get the URL for this user's banner.
+       * Returns null if the user has no banner (only available when fetched from profile/member context).
+       */
+      bannerURL(options) {
+        if (!this.banner) return null;
+        const ext = this.banner.startsWith("a_") ? "gif" : options?.extension ?? "png";
+        const size = options?.size ? `?size=${options.size}` : "";
+        return `${CDN_URL}/banners/${this.id}/${this.banner}.${ext}${size}`;
+      }
       /** Returns a mention string (e.g. `<@123456>`). */
       toString() {
         return `<@${this.id}>`;
@@ -788,7 +1788,7 @@ var init_User = __esm({
        */
       async createDM() {
         const { DMChannel: DMChannelClass } = await Promise.resolve().then(() => (init_Channel(), Channel_exports));
-        const data = await this.client.rest.post(import_types8.Routes.userMeChannels(), {
+        const data = await this.client.rest.post(import_types11.Routes.userMeChannels(), {
           body: { recipient_id: this.id },
           auth: true
         });
@@ -844,6 +1844,7 @@ var init_MessageReaction = __esm({
       /**
        * Fetch the message this reaction belongs to.
        * Use when you need to edit, delete, or otherwise interact with the message.
+       * @throws FluxerError with MESSAGE_NOT_FOUND if the message does not exist
        */
       async fetchMessage() {
         return this.client.channels.fetchMessage(this.channelId, this.messageId);
@@ -857,15 +1858,40 @@ var ClientUser_exports = {};
 __export(ClientUser_exports, {
   ClientUser: () => ClientUser
 });
-var ClientUser;
+var import_types12, ClientUser;
 var init_ClientUser = __esm({
   "src/client/ClientUser.ts"() {
     "use strict";
     init_User();
+    import_types12 = require("@fluxerjs/types");
     ClientUser = class extends User {
       constructor(client, data) {
         super(client, { ...data });
       }
+      /**
+       * Fetch guilds the bot is a member of.
+       * @returns Array of Guild objects (cached in client.guilds)
+       */
+      async fetchGuilds() {
+        const { Guild: Guild2 } = await Promise.resolve().then(() => (init_Guild(), Guild_exports));
+        const data = await this.client.rest.get(import_types12.Routes.currentUserGuilds());
+        const list = Array.isArray(data) ? data : data?.guilds ?? [];
+        const guilds = [];
+        for (const g of list) {
+          const guild = new Guild2(this.client, g);
+          this.client.guilds.set(guild.id, guild);
+          guilds.push(guild);
+        }
+        return guilds;
+      }
+      /**
+       * Leave a guild. Requires the bot to be a member.
+       * @param guildId - The guild ID to leave
+       */
+      async leaveGuild(guildId) {
+        await this.client.rest.delete(import_types12.Routes.leaveGuild(guildId), { auth: true });
+        this.client.guilds.delete(guildId);
+      }
     };
   }
 });
@@ -873,7 +1899,7 @@ var init_ClientUser = __esm({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AttachmentBuilder: () => import_builders2.AttachmentBuilder,
+  AttachmentBuilder: () => import_builders3.AttachmentBuilder,
   Base: () => Base,
   CategoryChannel: () => CategoryChannel,
   Channel: () => Channel,
@@ -881,39 +1907,60 @@ __export(index_exports, {
   Client: () => Client,
   ClientUser: () => ClientUser,
   DMChannel: () => DMChannel,
-  EmbedBuilder: () => import_builders2.EmbedBuilder,
+  EmbedBuilder: () => import_builders3.EmbedBuilder,
   ErrorCodes: () => ErrorCodes,
   Events: () => Events,
   FluxerError: () => FluxerError,
-  GatewayOpcodes: () => import_types10.GatewayOpcodes,
+  GatewayOpcodes: () => import_types16.GatewayOpcodes,
   Guild: () => Guild,
+  GuildBan: () => GuildBan,
   GuildChannel: () => GuildChannel,
+  GuildEmoji: () => GuildEmoji,
   GuildMember: () => GuildMember,
+  GuildSticker: () => GuildSticker,
+  Invite: () => Invite,
   LinkChannel: () => LinkChannel,
   Message: () => Message,
+  MessageAttachmentFlags: () => import_types16.MessageAttachmentFlags,
+  MessageCollector: () => MessageCollector,
   MessageManager: () => MessageManager,
-  MessagePayload: () => import_builders2.MessagePayload,
+  MessagePayload: () => import_builders3.MessagePayload,
   MessageReaction: () => MessageReaction,
+  PermissionFlags: () => import_util9.PermissionFlags,
+  PermissionsBitField: () => import_util9.PermissionsBitField,
+  ReactionCollector: () => ReactionCollector,
   Role: () => Role,
-  Routes: () => import_types10.Routes,
+  Routes: () => import_types16.Routes,
   TextChannel: () => TextChannel,
   User: () => User,
   VoiceChannel: () => VoiceChannel,
-  Webhook: () => Webhook
+  Webhook: () => Webhook,
+  cdnAvatarURL: () => cdnAvatarURL,
+  cdnBannerURL: () => cdnBannerURL,
+  cdnDefaultAvatarURL: () => cdnDefaultAvatarURL,
+  cdnDisplayAvatarURL: () => cdnDisplayAvatarURL,
+  cdnMemberAvatarURL: () => cdnMemberAvatarURL,
+  cdnMemberBannerURL: () => cdnMemberBannerURL,
+  resolveTenorToImageUrl: () => import_util8.resolveTenorToImageUrl
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/client/Client.ts
-var import_events = require("events");
-var import_rest = require("@fluxerjs/rest");
+var import_events3 = require("events");
+var import_rest3 = require("@fluxerjs/rest");
 var import_ws = require("@fluxerjs/ws");
-var import_types9 = require("@fluxerjs/types");
-var import_collection5 = require("@fluxerjs/collection");
+var import_types13 = require("@fluxerjs/types");
+var import_collection7 = require("@fluxerjs/collection");
 
 // src/client/ChannelManager.ts
-var import_collection2 = require("@fluxerjs/collection");
-var import_types4 = require("@fluxerjs/types");
-var ChannelManager = class extends import_collection2.Collection {
+var import_collection4 = require("@fluxerjs/collection");
+var import_types5 = require("@fluxerjs/types");
+var import_util2 = require("@fluxerjs/util");
+var import_rest = require("@fluxerjs/rest");
+init_FluxerError();
+init_ErrorCodes();
+init_messageUtils();
+var ChannelManager = class extends import_collection4.Collection {
   constructor(client) {
     super();
     this.client = client;
@@ -921,7 +1968,8 @@ var ChannelManager = class extends import_collection2.Collection {
   /**
    * Fetch a channel by ID from the API (or return from cache if present).
    * @param channelId - Snowflake of the channel
-   * @returns The channel, or null if not found
+   * @returns The channel
+   * @throws FluxerError with CHANNEL_NOT_FOUND if the channel does not exist
    * @example
    * const channel = await client.channels.fetch(channelId);
    * if (channel?.isSendable()) await channel.send('Hello!');
@@ -932,58 +1980,85 @@ var ChannelManager = class extends import_collection2.Collection {
     try {
       const { Channel: Channel2 } = await Promise.resolve().then(() => (init_Channel(), Channel_exports));
       const data = await this.client.rest.get(
-        import_types4.Routes.channel(channelId)
+        import_types5.Routes.channel(channelId)
       );
       const channel = Channel2.fromOrCreate(this.client, data);
-      if (channel) this.set(channel.id, channel);
+      if (!channel) {
+        throw new FluxerError("Channel data invalid or unsupported type", {
+          code: ErrorCodes.ChannelNotFound
+        });
+      }
+      this.set(channel.id, channel);
       return channel;
-    } catch {
-      return null;
+    } catch (err) {
+      if (err instanceof import_rest.RateLimitError) throw err;
+      if (err instanceof import_rest.FluxerAPIError && err.statusCode === 404) {
+        throw new FluxerError(`Channel ${channelId} not found`, {
+          code: ErrorCodes.ChannelNotFound,
+          cause: err
+        });
+      }
+      throw err instanceof FluxerError ? err : new FluxerError(String(err), { cause: err });
     }
   }
   /**
    * Fetch a message by ID from the API.
    * @param channelId - Snowflake of the channel
    * @param messageId - Snowflake of the message
-   * @returns The message, or null if not found
+   * @returns The message
+   * @throws FluxerError with MESSAGE_NOT_FOUND if the message does not exist
    * @deprecated Use channel.messages.fetch(messageId). Prefer (await client.channels.fetch(channelId))?.messages?.fetch(messageId).
    * @example
    * const channel = await client.channels.fetch(channelId);
    * const message = await channel?.messages?.fetch(messageId);
    */
   async fetchMessage(channelId, messageId) {
+    (0, import_util2.emitDeprecationWarning)(
+      "ChannelManager.fetchMessage()",
+      "Use channel.messages.fetch(messageId). Prefer (await client.channels.fetch(channelId))?.messages?.fetch(messageId)."
+    );
     try {
       const { Message: Message2 } = await Promise.resolve().then(() => (init_Message(), Message_exports));
       const data = await this.client.rest.get(
-        import_types4.Routes.channelMessage(channelId, messageId)
+        import_types5.Routes.channelMessage(channelId, messageId)
       );
       return new Message2(this.client, data);
-    } catch {
-      return null;
+    } catch (err) {
+      if (err instanceof import_rest.RateLimitError) throw err;
+      if (err instanceof import_rest.FluxerAPIError && err.statusCode === 404) {
+        throw new FluxerError(`Message ${messageId} not found in channel ${channelId}`, {
+          code: ErrorCodes.MessageNotFound,
+          cause: err
+        });
+      }
+      throw err instanceof FluxerError ? err : new FluxerError(String(err), { cause: err });
     }
   }
   /**
    * Send a message to a channel by ID. Works even when the channel is not cached.
    * Skips the fetch when you only need to send.
    * @param channelId - Snowflake of the channel (text channel or DM)
-   * @param payload - Text content or object with content and/or embeds
+   * @param payload - Text content or object with content, embeds, and/or files
    * @returns The created message
    * @example
    * await client.channels.send(logChannelId, 'User joined!');
    * await client.channels.send(channelId, { embeds: [embed.toJSON()] });
+   * await client.channels.send(channelId, { content: 'Report', files: [{ name: 'log.txt', data }] });
    */
   async send(channelId, payload) {
-    const body = typeof payload === "string" ? { content: payload } : payload;
+    const opts = typeof payload === "string" ? { content: payload } : payload;
+    const body = buildSendBody(payload);
     const { Message: Message2 } = await Promise.resolve().then(() => (init_Message(), Message_exports));
-    const data = await this.client.rest.post(import_types4.Routes.channelMessages(channelId), { body });
+    const postOptions = opts.files?.length ? { body, files: opts.files } : { body };
+    const data = await this.client.rest.post(import_types5.Routes.channelMessages(channelId), postOptions);
     return new Message2(this.client, data);
   }
 };
 
 // src/client/GuildManager.ts
-var import_collection4 = require("@fluxerjs/collection");
-var import_types7 = require("@fluxerjs/types");
-var GuildManager = class extends import_collection4.Collection {
+var import_collection6 = require("@fluxerjs/collection");
+var import_types10 = require("@fluxerjs/types");
+var GuildManager = class extends import_collection6.Collection {
   constructor(client) {
     super();
     this.client = client;
@@ -1002,7 +2077,7 @@ var GuildManager = class extends import_collection4.Collection {
     try {
       const { Guild: Guild2 } = await Promise.resolve().then(() => (init_Guild(), Guild_exports));
       const data = await this.client.rest.get(
-        import_types7.Routes.guild(guildId)
+        import_types10.Routes.guild(guildId)
       );
       const guild = new Guild2(this.client, data);
       this.set(guild.id, guild);
@@ -1013,71 +2088,29 @@ var GuildManager = class extends import_collection4.Collection {
   }
 };
 
-// src/errors/FluxerError.ts
-var FluxerError = class _FluxerError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "FluxerError";
-    Object.setPrototypeOf(this, _FluxerError.prototype);
-  }
-};
-
-// src/util/Events.ts
-var Events = {
-  Ready: "ready",
-  MessageCreate: "messageCreate",
-  MessageUpdate: "messageUpdate",
-  MessageDelete: "messageDelete",
-  MessageDeleteBulk: "messageDeleteBulk",
-  MessageReactionAdd: "messageReactionAdd",
-  MessageReactionRemove: "messageReactionRemove",
-  MessageReactionRemoveAll: "messageReactionRemoveAll",
-  MessageReactionRemoveEmoji: "messageReactionRemoveEmoji",
-  InteractionCreate: "interactionCreate",
-  GuildCreate: "guildCreate",
-  GuildUpdate: "guildUpdate",
-  GuildDelete: "guildDelete",
-  GuildBanAdd: "guildBanAdd",
-  GuildBanRemove: "guildBanRemove",
-  GuildEmojisUpdate: "guildEmojisUpdate",
-  GuildStickersUpdate: "guildStickersUpdate",
-  GuildIntegrationsUpdate: "guildIntegrationsUpdate",
-  GuildMemberAdd: "guildMemberAdd",
-  GuildMemberUpdate: "guildMemberUpdate",
-  GuildMemberRemove: "guildMemberRemove",
-  GuildRoleCreate: "guildRoleCreate",
-  GuildRoleUpdate: "guildRoleUpdate",
-  GuildRoleDelete: "guildRoleDelete",
-  GuildScheduledEventCreate: "guildScheduledEventCreate",
-  GuildScheduledEventUpdate: "guildScheduledEventUpdate",
-  GuildScheduledEventDelete: "guildScheduledEventDelete",
-  ChannelCreate: "channelCreate",
-  ChannelUpdate: "channelUpdate",
-  ChannelDelete: "channelDelete",
-  ChannelPinsUpdate: "channelPinsUpdate",
-  InviteCreate: "inviteCreate",
-  InviteDelete: "inviteDelete",
-  TypingStart: "typingStart",
-  UserUpdate: "userUpdate",
-  PresenceUpdate: "presenceUpdate",
-  VoiceStateUpdate: "voiceStateUpdate",
-  VoiceServerUpdate: "voiceServerUpdate",
-  VoiceStatesSync: "voiceStatesSync",
-  WebhooksUpdate: "webhooksUpdate",
-  Resumed: "resumed",
-  Error: "error",
-  Debug: "debug"
-};
-
 // src/client/Client.ts
-var import_util2 = require("@fluxerjs/util");
+init_FluxerError();
+init_ErrorCodes();
+init_Events();
+var import_util7 = require("@fluxerjs/util");
 init_User();
 
 // src/client/EventHandlerRegistry.ts
+init_Events();
 var handlers = /* @__PURE__ */ new Map();
 handlers.set("MESSAGE_CREATE", async (client, d) => {
   const { Message: Message2 } = await Promise.resolve().then(() => (init_Message(), Message_exports));
-  client.emit(Events.MessageCreate, new Message2(client, d));
+  const { GuildMember: GuildMember2 } = await Promise.resolve().then(() => (init_GuildMember(), GuildMember_exports));
+  const data = d;
+  if (data.guild_id && data.member && data.author) {
+    const guild = client.guilds.get(data.guild_id);
+    if (guild) {
+      const memberData = { ...data.member, user: data.author, guild_id: data.guild_id };
+      const member = new GuildMember2(client, memberData, guild);
+      guild.members.set(member.id, member);
+    }
+  }
+  client.emit(Events.MessageCreate, new Message2(client, data));
 });
 handlers.set("MESSAGE_UPDATE", async (client, d) => {
   const { Message: Message2 } = await Promise.resolve().then(() => (init_Message(), Message_exports));
@@ -1101,7 +2134,15 @@ handlers.set("MESSAGE_REACTION_ADD", async (client, d) => {
     username: "Unknown",
     discriminator: "0"
   });
-  client.emit(Events.MessageReactionAdd, reaction, user);
+  client.emit(
+    Events.MessageReactionAdd,
+    reaction,
+    user,
+    reaction.messageId,
+    reaction.channelId,
+    reaction.emoji,
+    user.id
+  );
 });
 handlers.set("MESSAGE_REACTION_REMOVE", async (client, d) => {
   const data = d;
@@ -1112,7 +2153,15 @@ handlers.set("MESSAGE_REACTION_REMOVE", async (client, d) => {
     username: "Unknown",
     discriminator: "0"
   });
-  client.emit(Events.MessageReactionRemove, reaction, user);
+  client.emit(
+    Events.MessageReactionRemove,
+    reaction,
+    user,
+    reaction.messageId,
+    reaction.channelId,
+    reaction.emoji,
+    user.id
+  );
 });
 handlers.set("MESSAGE_REACTION_REMOVE_ALL", async (client, d) => {
   client.emit(Events.MessageReactionRemoveAll, d);
@@ -1126,7 +2175,9 @@ handlers.set("MESSAGE_REACTION_REMOVE_EMOJI", async (client, d) => {
 handlers.set("GUILD_CREATE", async (client, d) => {
   const { Guild: Guild2 } = await Promise.resolve().then(() => (init_Guild(), Guild_exports));
   const { Channel: Channel2 } = await Promise.resolve().then(() => (init_Channel(), Channel_exports));
-  const guild = new Guild2(client, d);
+  const raw = d;
+  const guildData = raw?.properties != null ? { ...raw.properties, roles: raw.roles } : raw;
+  const guild = new Guild2(client, guildData);
   client.guilds.set(guild.id, guild);
   const g = d;
   for (const ch of g.channels ?? []) {
@@ -1140,9 +2191,10 @@ handlers.set("GUILD_CREATE", async (client, d) => {
 });
 handlers.set("GUILD_UPDATE", async (client, d) => {
   const { Guild: Guild2 } = await Promise.resolve().then(() => (init_Guild(), Guild_exports));
-  const g = d;
-  const old = client.guilds.get(g.id);
-  const updated = new Guild2(client, g);
+  const raw = d;
+  const guildData = raw?.properties != null ? { ...raw.properties, roles: raw.roles } : raw;
+  const old = client.guilds.get(guildData.id);
+  const updated = new Guild2(client, guildData);
   client.guilds.set(updated.id, updated);
   client.emit(Events.GuildUpdate, old ?? updated, updated);
 });
@@ -1225,10 +2277,16 @@ handlers.set("MESSAGE_DELETE_BULK", async (client, d) => {
   client.emit(Events.MessageDeleteBulk, d);
 });
 handlers.set("GUILD_BAN_ADD", async (client, d) => {
-  client.emit(Events.GuildBanAdd, d);
+  const data = d;
+  const { GuildBan: GuildBan2 } = await Promise.resolve().then(() => (init_GuildBan(), GuildBan_exports));
+  const ban = new GuildBan2(client, data, data.guild_id);
+  client.emit(Events.GuildBanAdd, ban);
 });
 handlers.set("GUILD_BAN_REMOVE", async (client, d) => {
-  client.emit(Events.GuildBanRemove, d);
+  const data = d;
+  const { GuildBan: GuildBan2 } = await Promise.resolve().then(() => (init_GuildBan(), GuildBan_exports));
+  const ban = new GuildBan2(client, { ...data, reason: null }, data.guild_id);
+  client.emit(Events.GuildBanRemove, ban);
 });
 handlers.set("GUILD_EMOJIS_UPDATE", async (client, d) => {
   client.emit(Events.GuildEmojisUpdate, d);
@@ -1276,7 +2334,9 @@ handlers.set("CHANNEL_PINS_UPDATE", async (client, d) => {
   client.emit(Events.ChannelPinsUpdate, d);
 });
 handlers.set("INVITE_CREATE", async (client, d) => {
-  client.emit(Events.InviteCreate, d);
+  const data = d;
+  const { Invite: Invite2 } = await Promise.resolve().then(() => (init_Invite(), Invite_exports));
+  client.emit(Events.InviteCreate, new Invite2(client, data));
 });
 handlers.set("INVITE_DELETE", async (client, d) => {
   client.emit(Events.InviteDelete, d);
@@ -1303,11 +2363,23 @@ handlers.set("RESUMED", async (client) => {
 var eventHandlers = handlers;
 
 // src/client/Client.ts
-var Client = class extends import_events.EventEmitter {
+function createEventMethods(client) {
+  const result = {};
+  for (const key of Object.keys(Events)) {
+    const eventName = Events[key];
+    result[key] = (cb) => {
+      client.on(eventName, cb);
+      return client;
+    };
+  }
+  return result;
+}
+var Client = class extends import_events3.EventEmitter {
   /** @param options - Token, REST config, WebSocket, presence, etc. */
   constructor(options = {}) {
     super();
     this.options = options;
+    this.events = createEventMethods(this);
     Object.defineProperty(this.channels, "cache", {
       get: () => this.channels,
       configurable: true
@@ -1316,7 +2388,7 @@ var Client = class extends import_events.EventEmitter {
       get: () => this.guilds,
       configurable: true
     });
-    this.rest = new import_rest.REST({
+    this.rest = new import_rest3.REST({
       api: options.rest?.api ?? "https://api.fluxer.app",
       version: options.rest?.version ?? "1",
       ...options.rest
@@ -1325,8 +2397,12 @@ var Client = class extends import_events.EventEmitter {
   rest;
   guilds = new GuildManager(this);
   channels = new ChannelManager(this);
-  users = new import_collection5.Collection();
+  users = new import_collection7.Collection();
+  /** Typed event handlers. Use client.events.MessageReactionAdd((reaction, user, messageId, channelId, emoji, userId) => {...}) or client.on(Events.MessageReactionAdd, ...). */
+  events;
+  /** The authenticated bot user. Null until READY is received. */
   user = null;
+  /** Timestamp when the client became ready. Null until READY is received. */
   readyAt = null;
   _ws = null;
   /**
@@ -1339,16 +2415,16 @@ var Client = class extends import_events.EventEmitter {
    */
   async resolveEmoji(emoji, guildId) {
     if (typeof emoji === "object" && emoji.id) {
-      return (0, import_util2.formatEmoji)({ name: emoji.name, id: emoji.id, animated: emoji.animated });
+      return (0, import_util7.formatEmoji)({ name: emoji.name, id: emoji.id, animated: emoji.animated });
     }
-    const parsed = (0, import_util2.parseEmoji)(typeof emoji === "string" ? emoji : `:${emoji.name}:`);
+    const parsed = (0, import_util7.parseEmoji)(typeof emoji === "string" ? emoji : `:${emoji.name}:`);
     if (!parsed) throw new Error("Invalid emoji");
-    if (parsed.id) return (0, import_util2.formatEmoji)(parsed);
+    if (parsed.id) return (0, import_util7.formatEmoji)(parsed);
     if (guildId) {
-      const emojis = await this.rest.get(import_types9.Routes.guildEmojis(guildId));
+      const emojis = await this.rest.get(import_types13.Routes.guildEmojis(guildId));
       const list = Array.isArray(emojis) ? emojis : Object.values(emojis ?? {});
       const found = list.find((e) => e.name && e.name.toLowerCase() === parsed.name.toLowerCase());
-      if (found) return (0, import_util2.formatEmoji)({ ...parsed, id: found.id, animated: found.animated });
+      if (found) return (0, import_util7.formatEmoji)({ ...parsed, id: found.id, animated: found.animated });
       throw new Error(
         `Custom emoji ":${parsed.name}:" not found in guild. Use name:id or <:name:id> format.`
       );
@@ -1364,13 +2440,18 @@ var Client = class extends import_events.EventEmitter {
    * Fetch a message by channel and message ID. Use when you have IDs (e.g. from a DB).
    * @param channelId - Snowflake of the channel
    * @param messageId - Snowflake of the message
-   * @returns The message, or null if not found
+   * @returns The message
+   * @throws FluxerError with MESSAGE_NOT_FOUND if the message does not exist
    * @deprecated Use channel.messages.fetch(messageId). For IDs-only: (await client.channels.fetch(channelId))?.messages?.fetch(messageId)
    * @example
    * const channel = await client.channels.fetch(channelId);
    * const message = await channel?.messages?.fetch(messageId);
    */
   async fetchMessage(channelId, messageId) {
+    (0, import_util7.emitDeprecationWarning)(
+      "Client.fetchMessage()",
+      "Use channel.messages.fetch(messageId). For IDs-only: (await client.channels.fetch(channelId))?.messages?.fetch(messageId)"
+    );
     return this.channels.fetchMessage(channelId, messageId);
   }
   /**
@@ -1423,7 +2504,9 @@ var Client = class extends import_events.EventEmitter {
    */
   async login(token) {
     if (this._ws) {
-      throw new FluxerError("Client is already logged in. Call destroy() first.");
+      throw new FluxerError("Client is already logged in. Call destroy() first.", {
+        code: ErrorCodes.AlreadyLoggedIn
+      });
     }
     this.rest.setToken(token);
     let intents = this.options.intents ?? 0;
@@ -1460,7 +2543,11 @@ var Client = class extends import_events.EventEmitter {
         const { Channel: Channel2 } = await Promise.resolve().then(() => (init_Channel(), Channel_exports));
         this.user = new ClientUser2(this, data.user);
         for (const g of data.guilds ?? []) {
-          const guild = new Guild2(this, g);
+          const guildData = g && typeof g === "object" && "properties" in g && g.properties ? {
+            ...g.properties,
+            roles: g.roles
+          } : g;
+          const guild = new Guild2(this, guildData);
           this.guilds.set(guild.id, guild);
           const withCh = g;
           for (const ch of withCh.channels ?? []) {
@@ -1501,7 +2588,7 @@ var Client = class extends import_events.EventEmitter {
     return this.readyAt !== null && this.user !== null;
   }
   static get Routes() {
-    return import_types9.Routes;
+    return import_types13.Routes;
   }
 };
 
@@ -1517,16 +2604,118 @@ init_MessageReaction();
 init_Webhook();
 init_GuildMember();
 init_Role();
+init_Invite();
+init_GuildBan();
 
-// src/errors/ErrorCodes.ts
-var ErrorCodes = {
-  ClientNotReady: "CLIENT_NOT_READY",
-  InvalidToken: "INVALID_TOKEN"
+// src/structures/GuildEmoji.ts
+init_Base();
+var import_types14 = require("@fluxerjs/types");
+init_Constants();
+var GuildEmoji = class extends Base {
+  client;
+  id;
+  guildId;
+  name;
+  animated;
+  /** @param data - API emoji from GET /guilds/{id}/emojis or guild emoji events */
+  constructor(client, data, guildId) {
+    super();
+    this.client = client;
+    this.id = data.id;
+    this.guildId = data.guild_id ?? guildId;
+    this.name = data.name;
+    this.animated = data.animated ?? false;
+  }
+  /** CDN URL for this emoji image. */
+  get url() {
+    const ext = this.animated ? "gif" : "png";
+    return `${CDN_URL}/emojis/${this.id}.${ext}`;
+  }
+  /** Emoji identifier for use in reactions: `name:id` */
+  get identifier() {
+    return `${this.name}:${this.id}`;
+  }
+  /** Delete this emoji. Requires Manage Emojis and Stickers permission. */
+  async delete() {
+    await this.client.rest.delete(import_types14.Routes.guildEmoji(this.guildId, this.id), {
+      auth: true
+    });
+  }
+  /**
+   * Edit this emoji's name.
+   * Requires Manage Emojis and Stickers permission.
+   */
+  async edit(options) {
+    const data = await this.client.rest.patch(import_types14.Routes.guildEmoji(this.guildId, this.id), {
+      body: options,
+      auth: true
+    });
+    this.name = data.name;
+    return this;
+  }
+};
+
+// src/structures/GuildSticker.ts
+init_Base();
+var import_types15 = require("@fluxerjs/types");
+init_Constants();
+var GuildSticker = class extends Base {
+  client;
+  id;
+  guildId;
+  name;
+  description;
+  tags;
+  animated;
+  /** @param data - API sticker from GET /guilds/{id}/stickers or guild sticker events */
+  constructor(client, data, guildId) {
+    super();
+    this.client = client;
+    this.id = data.id;
+    this.guildId = data.guild_id ?? guildId;
+    this.name = data.name;
+    this.description = data.description ?? "";
+    this.tags = data.tags ?? [];
+    this.animated = data.animated ?? false;
+  }
+  /** CDN URL for this sticker image. */
+  get url() {
+    const ext = this.animated ? "gif" : "png";
+    return `${CDN_URL}/stickers/${this.id}.${ext}`;
+  }
+  /** Delete this sticker. Requires Manage Emojis and Stickers permission. */
+  async delete() {
+    await this.client.rest.delete(import_types15.Routes.guildSticker(this.guildId, this.id), {
+      auth: true
+    });
+  }
+  /**
+   * Edit this sticker's name and/or description.
+   * Requires Manage Emojis and Stickers permission.
+   */
+  async edit(options) {
+    const data = await this.client.rest.patch(import_types15.Routes.guildSticker(this.guildId, this.id), {
+      body: options,
+      auth: true
+    });
+    const s = data;
+    this.name = s.name;
+    this.description = s.description ?? "";
+    return this;
+  }
 };
 
 // src/index.ts
-var import_builders2 = require("@fluxerjs/builders");
-var import_types10 = require("@fluxerjs/types");
+init_Events();
+init_MessageCollector();
+init_ReactionCollector();
+init_FluxerError();
+init_ErrorCodes();
+var import_builders3 = require("@fluxerjs/builders");
+var import_types16 = require("@fluxerjs/types");
+var import_util8 = require("@fluxerjs/util");
+var import_util9 = require("@fluxerjs/util");
+init_cdn();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AttachmentBuilder,
@@ -1543,17 +2732,33 @@ var import_types10 = require("@fluxerjs/types");
   FluxerError,
   GatewayOpcodes,
   Guild,
+  GuildBan,
   GuildChannel,
+  GuildEmoji,
   GuildMember,
+  GuildSticker,
+  Invite,
   LinkChannel,
   Message,
+  MessageAttachmentFlags,
+  MessageCollector,
   MessageManager,
   MessagePayload,
   MessageReaction,
+  PermissionFlags,
+  PermissionsBitField,
+  ReactionCollector,
   Role,
   Routes,
   TextChannel,
   User,
   VoiceChannel,
-  Webhook
+  Webhook,
+  cdnAvatarURL,
+  cdnBannerURL,
+  cdnDefaultAvatarURL,
+  cdnDisplayAvatarURL,
+  cdnMemberAvatarURL,
+  cdnMemberBannerURL,
+  resolveTenorToImageUrl
 });