@erinjs/core 1.0.0 → 1.2.4

package/dist/index.mjs

@@ -0,0 +1,3809 @@
+// src/client/Client.ts
+import { EventEmitter as EventEmitter3 } from "events";
+import { REST } from "@erinjs/rest";
+import { WebSocketManager } from "@erinjs/ws";
+import {
+  Routes as Routes20
+} from "@erinjs/types";
+
+// src/client/ChannelManager.ts
+import { Collection as Collection4 } from "@erinjs/collection";
+import { Routes as Routes6 } from "@erinjs/types";
+import { emitDeprecationWarning as emitDeprecationWarning2 } from "@erinjs/util";
+import { FluxerAPIError as FluxerAPIError2, RateLimitError as RateLimitError2 } from "@erinjs/rest";
+
+// src/errors/FluxerError.ts
+var 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 = {
+  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",
+  RoleNotFound: "ROLE_NOT_FOUND",
+  EmojiNotInGuild: "EMOJI_NOT_IN_GUILD",
+  EmojiNotFound: "EMOJI_NOT_FOUND"
+};
+
+// src/util/messageUtils.ts
+import { EmbedBuilder } from "@erinjs/builders";
+var FILE_FETCH_TIMEOUT_MS = 3e4;
+async function resolveMessageFiles(files) {
+  const result = [];
+  for (let i = 0; i < files.length; i++) {
+    const f = files[i];
+    const filename = f.filename ?? f.name;
+    if ("url" in f && f.url) {
+      if (!URL.canParse(f.url)) {
+        throw new Error(`Invalid file URL at index ${i}: ${f.url}`);
+      }
+      const res = await fetch(f.url, {
+        signal: AbortSignal.timeout(FILE_FETCH_TIMEOUT_MS)
+      });
+      if (!res.ok) {
+        throw new Error(`Failed to fetch file from ${f.url}: ${res.status} ${res.statusText}`);
+      }
+      const data = await res.arrayBuffer();
+      result.push({ name: f.name, data, filename });
+    } else if ("data" in f && f.data != null) {
+      result.push({ name: f.name, data: f.data, filename });
+    } else {
+      throw new Error(`File at index ${i} must have either "data" or "url"`);
+    }
+  }
+  return result;
+}
+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 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
+    }));
+  }
+  if (body.flags !== void 0) result.flags = body.flags;
+  return result;
+}
+
+// src/client/MessageManager.ts
+import { Routes as Routes2 } from "@erinjs/types";
+import { FluxerAPIError, RateLimitError } from "@erinjs/rest";
+
+// src/structures/Base.ts
+var Base = class {
+};
+
+// src/structures/Message.ts
+import { Collection as Collection2 } from "@erinjs/collection";
+import { MessageType, MessageFlags, Routes } from "@erinjs/types";
+import { EmbedBuilder as EmbedBuilder2 } from "@erinjs/builders";
+
+// src/util/ReactionCollector.ts
+import { EventEmitter } from "events";
+import { Collection } from "@erinjs/collection";
+
+// 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",
+  GuildMembersChunk: "guildMembersChunk",
+  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/ReactionCollector.ts
+var ReactionCollector = class extends EventEmitter {
+  client;
+  messageId;
+  channelId;
+  options;
+  collected = new Collection();
+  _timeout = null;
+  _ended = false;
+  _listener;
+  constructor(client, messageId, channelId, options = {}) {
+    super();
+    this.client = client;
+    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);
+    }
+  }
+  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;
+    }
+    this.emit("end", this.collected, reason);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+};
+
+// src/structures/Message.ts
+var Message = class _Message extends Base {
+  client;
+  id;
+  channelId;
+  guildId;
+  author;
+  content;
+  createdAt;
+  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.
+   * Messages can only exist in text-based channels (text, DM, announcement), so this always has send() when non-null.
+   */
+  get channel() {
+    return this.client.channels.get(this.channelId) ?? null;
+  }
+  /** Guild where this message was sent. Resolved from cache; null for DMs or if not cached. */
+  get guild() {
+    return this.guildId ? this.client.guilds.get(this.guildId) ?? null : null;
+  }
+  /**
+   * Resolve the channel (from cache or API). Use when you need the channel and it may not be cached.
+   * @returns The channel
+   * @throws FluxerError with CHANNEL_NOT_FOUND if the channel does not exist
+   */
+  async resolveChannel() {
+    return this.client.channels.resolve(this.channelId);
+  }
+  /**
+   * Resolve the guild (from cache or API). Returns null for DMs.
+   * @returns The guild, or null if this is a DM or guild not found
+   */
+  async resolveGuild() {
+    return this.guildId ? this.client.guilds.resolve(this.guildId) : null;
+  }
+  /** @param data - API message from POST/PATCH /channels/{id}/messages or gateway MESSAGE_CREATE */
+  constructor(client, data) {
+    super();
+    this.client = client;
+    this.id = data.id;
+    this.channelId = data.channel_id;
+    this.guildId = data.guild_id ?? null;
+    this.author = client.getOrCreateUser(data.author);
+    this.content = data.content;
+    this.createdAt = new Date(data.timestamp);
+    this.editedAt = data.edited_timestamp ? new Date(data.edited_timestamp) : null;
+    this.pinned = data.pinned;
+    this.attachments = new Collection2();
+    for (const a of data.attachments ?? []) this.attachments.set(a.id, a);
+    this.type = data.type ?? 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, embeds, and/or files
+   * @example
+   * await message.send('Pong!');
+   * await message.send({ embeds: [embed] }); // EmbedBuilder auto-converted
+   * await message.send({ content: 'File', files: [{ name: 'data.txt', data }] });
+   */
+  async send(options) {
+    const payload = await _Message._createMessageBody(options);
+    return this._send(payload);
+  }
+  /**
+   * Send a message to a specific channel. Use for logging, forwarding, or sending to another channel in the guild.
+   * @param channelId - Snowflake of the target channel (e.g. log channel ID)
+   * @param options - Text content or object with content and/or embeds
+   * @example
+   * await message.sendTo(logChannelId, 'User ' + message.author.username + ' said: ' + message.content);
+   * await message.sendTo(announceChannelId, { embeds: [embed] });
+   */
+  async sendTo(channelId, options) {
+    return this.client.channels.send(channelId, options);
+  }
+  /**
+   * Reply to this message (shows as a reply in the client).
+   * @param options - Text content or object with content, embeds, and/or reply options (ping, replyTo)
+   * @example
+   * await message.reply('Pong!');
+   * await message.reply({ embeds: [embed] });
+   * await message.reply('No ping!', { ping: false });
+   * await message.reply({ content: 'Reply to other', replyTo: otherMessage });
+   */
+  async reply(options, replyOptions) {
+    const opts = typeof options === "string" ? { content: options } : options;
+    const mergedReply = replyOptions ?? (opts.ping !== void 0 || opts.replyTo !== void 0) ? { ping: opts.ping, replyTo: opts.replyTo } : void 0;
+    const refMessage = mergedReply?.replyTo ?? this;
+    const ref = refMessage instanceof _Message ? {
+      channel_id: refMessage.channelId,
+      message_id: refMessage.id,
+      guild_id: refMessage.guildId ?? void 0
+    } : {
+      channel_id: refMessage.channelId,
+      message_id: refMessage.messageId,
+      guild_id: void 0
+    };
+    const payload = await _Message._createMessageBody(opts, ref, mergedReply?.ping !== false);
+    return this._send(payload);
+  }
+  /** Exposed for testing purposes, use Message.reply() or send() for normal use */
+  static async _createMessageBody(content, referenced_message, ping) {
+    if (typeof content === "string") {
+      if (content.length === 0) {
+        throw new RangeError("Cannot send an empty message");
+      }
+      content = { content };
+    }
+    const base = buildSendBody(content);
+    const files = content.files?.length ? await resolveMessageFiles(content.files) : void 0;
+    const body = { ...base };
+    if (referenced_message) {
+      body.message_reference = referenced_message;
+      if (ping === false) {
+        body.flags = (body.flags ?? 0) | MessageFlags.SuppressNotifications;
+      }
+    }
+    return { files, body };
+  }
+  async _send(payload) {
+    const data = await this.client.rest.post(
+      Routes.channelMessages(this.channelId),
+      payload
+    );
+    this.client._addMessageToCache(this.channelId, data);
+    return new _Message(this.client, data);
+  }
+  /**
+   * Edit this message. Only the author (or admins) can edit.
+   * @param options - New content and/or embeds
+   */
+  async edit(options) {
+    const body = {};
+    if (options.content !== void 0) body.content = options.content;
+    if (options.embeds?.length) {
+      body.embeds = options.embeds.map((e) => e instanceof EmbedBuilder2 ? e.toJSON() : e);
+    }
+    const data = await this.client.rest.patch(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
+   * @throws FluxerError with MESSAGE_NOT_FOUND if the message was deleted or does not exist
+   * @example
+   * const updated = await message.fetch();
+   * 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(Routes.channelMessage(this.channelId, this.id));
+  }
+  /**
+   * Delete a specific attachment from this message.
+   * DELETE /channels/{id}/messages/{id}/attachments/{attachmentId}.
+   */
+  async deleteAttachment(attachmentId) {
+    await this.client.rest.delete(
+      Routes.channelMessageAttachment(this.channelId, this.id, attachmentId),
+      { auth: true }
+    );
+    this.attachments.delete(attachmentId);
+  }
+  /** Pin this message to the channel. Requires Manage Messages permission. */
+  async pin() {
+    await this.client.rest.put(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(Routes.channelPinMessage(this.channelId, this.id));
+    this.pinned = false;
+  }
+  /**
+   * Format emoji for reaction API: unicode string or "name:id" for custom.
+   * For string resolution (e.g. :name:), use client.resolveEmoji; Message methods resolve automatically when guildId is available.
+   */
+  static formatEmoji(emoji) {
+    if (typeof emoji === "string") return emoji;
+    return `${emoji.name}:${emoji.id}`;
+  }
+  resolveEmojiForReaction(emoji) {
+    return this.client.resolveEmoji(emoji, this.guildId);
+  }
+  /**
+   * Add a reaction to this message (as the bot).
+   * @param emoji - Unicode emoji, custom `{ name, id }`, `:name:`, `name:id`, or `<:name:id>`
+   */
+  async react(emoji) {
+    const emojiStr = await this.resolveEmojiForReaction(emoji);
+    const route = `${Routes.channelMessageReaction(this.channelId, this.id, emojiStr)}/@me`;
+    await this.client.rest.put(route);
+  }
+  /**
+   * Remove the bot's reaction, or a specific user's reaction if userId is provided.
+   * @param emoji - Unicode emoji, custom `{ name, id }`, `:name:`, `name:id`, or `<:name:id>`
+   * @param userId - If provided, removes that user's reaction (requires moderator permissions)
+   */
+  async removeReaction(emoji, userId) {
+    const emojiStr = await this.resolveEmojiForReaction(emoji);
+    const route = `${Routes.channelMessageReaction(this.channelId, this.id, emojiStr)}/${userId ?? "@me"}`;
+    await this.client.rest.delete(route);
+  }
+  /**
+   * Remove all reactions from this message.
+   * Requires moderator permissions.
+   */
+  async removeAllReactions() {
+    await this.client.rest.delete(Routes.channelMessageReactions(this.channelId, this.id));
+  }
+  /**
+   * Remove all reactions of a specific emoji from this message.
+   * @param emoji - Unicode emoji, custom `{ name, id }`, `:name:`, `name:id`, or `<:name:id>`. Requires moderator permissions.
+   */
+  async removeReactionEmoji(emoji) {
+    const emojiStr = await this.resolveEmojiForReaction(emoji);
+    await this.client.rest.delete(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 = 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/client/MessageManager.ts
+var MessageManager = class {
+  constructor(client, channelId) {
+    this.client = client;
+    this.channelId = channelId;
+  }
+  /**
+   * Get a message from cache. Returns undefined if not cached or caching is disabled.
+   * Requires options.cache.messages > 0.
+   * @param messageId - Snowflake of the message
+   */
+  get(messageId) {
+    const data = this.client._getMessageCache(this.channelId)?.get(messageId);
+    return data ? new Message(this.client, data) : void 0;
+  }
+  /**
+   * Fetch a message by ID from this channel.
+   * When message caching is enabled, the fetched message is added to the cache.
+   * @param messageId - Snowflake of the message
+   * @returns The message
+   * @throws FluxerError with MESSAGE_NOT_FOUND if the message does not exist
+   */
+  async fetch(messageId) {
+    try {
+      const data = await this.client.rest.get(
+        Routes2.channelMessage(this.channelId, messageId)
+      );
+      this.client._addMessageToCache(this.channelId, data);
+      return new Message(this.client, data);
+    } catch (err) {
+      if (err instanceof RateLimitError) throw err;
+      if (err instanceof FluxerAPIError && err.statusCode === 404) {
+        throw new FluxerError(`Message ${messageId} not found in channel ${this.channelId}`, {
+          code: ErrorCodes.MessageNotFound,
+          cause: err
+        });
+      }
+      throw err instanceof FluxerError ? err : new FluxerError(String(err), { cause: err });
+    }
+  }
+};
+
+// src/util/MessageCollector.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import { Collection as Collection3 } from "@erinjs/collection";
+var MessageCollector = class extends EventEmitter2 {
+  client;
+  channelId;
+  options;
+  collected = new Collection3();
+  _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/Channel.ts
+import { ChannelType, Routes as Routes5 } from "@erinjs/types";
+import { PermissionFlags } from "@erinjs/util";
+import { emitDeprecationWarning } from "@erinjs/util";
+
+// src/structures/Webhook.ts
+import { Routes as Routes3 } from "@erinjs/types";
+
+// src/util/Constants.ts
+var CDN_URL = "https://fluxerusercontent.com";
+var STATIC_CDN_URL = "https://fluxerstatic.com";
+
+// 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) ?? cdnDefaultAvatarURL(userId);
+}
+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(userIdOrIndex) {
+  const index = typeof userIdOrIndex === "string" ? Number(BigInt(userIdOrIndex) % 6n) : Math.abs(Math.floor(userIdOrIndex) % 6);
+  return `${STATIC_CDN_URL}/avatars/${index}.png`;
+}
+
+// src/structures/Webhook.ts
+var 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(Routes3.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(Routes3.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(Routes3.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] });
+   * 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(opts);
+    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 = Routes3.webhookExecute(this.id, this.token) + (wait ? "?wait=true" : "");
+    const files = opts.files?.length ? await resolveMessageFiles(opts.files) : void 0;
+    const postOptions = files?.length ? { body, files, auth: false } : { body, auth: false };
+    const data = await this.client.rest.post(route, postOptions);
+    if (wait && data) {
+      return new Message(this.client, data);
+    }
+    return void 0;
+  }
+  /**
+   * Edit a message previously sent by this webhook.
+   * Requires the webhook token.
+   * @param messageId - The ID of the message to edit
+   * @param options - Fields to update (content, embeds, attachments)
+   * @returns The updated Message
+   * @throws Error if token is not available
+   */
+  async editMessage(messageId, options) {
+    if (!this.token) {
+      throw new Error(
+        "Webhook token is required to edit messages. The token is only returned when creating a webhook; fetched webhooks cannot edit messages."
+      );
+    }
+    const data = await this.client.rest.patch(
+      Routes3.webhookMessage(this.id, this.token, messageId),
+      { body: options, auth: false }
+    );
+    return new Message(this.client, data);
+  }
+  /**
+   * Fetch a message sent by this webhook.
+   * Requires the webhook token.
+   * @param messageId - The ID of the message to fetch
+   * @returns The message
+   * @throws Error if token is not available
+   */
+  async fetchMessage(messageId) {
+    if (!this.token) {
+      throw new Error(
+        "Webhook token is required to fetch messages. The token is only returned when creating a webhook; fetched webhooks cannot fetch messages."
+      );
+    }
+    const data = await this.client.rest.get(
+      Routes3.webhookMessage(this.id, this.token, messageId),
+      { auth: false }
+    );
+    return new Message(this.client, data);
+  }
+  /**
+   * Delete a message sent by this webhook.
+   * Requires the webhook token.
+   * @param messageId - The ID of the message to delete
+   * @throws Error if token is not available
+   */
+  async deleteMessage(messageId) {
+    if (!this.token) {
+      throw new Error(
+        "Webhook token is required to delete messages. The token is only returned when creating a webhook; fetched webhooks cannot delete messages."
+      );
+    }
+    await this.client.rest.delete(Routes3.webhookMessage(this.id, this.token, messageId), {
+      auth: false
+    });
+  }
+  /**
+   * 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(Routes3.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
+import { Routes as Routes4 } from "@erinjs/types";
+var Invite = class _Invite extends Base {
+  client;
+  code;
+  type;
+  guild;
+  channel;
+  inviter;
+  memberCount;
+  presenceCount;
+  expiresAt;
+  temporary;
+  createdAt;
+  uses;
+  maxUses;
+  maxAge;
+  /**
+   * Normalize an invite input into a raw invite code.
+   * Accepts either an invite code (e.g. "abc123") or a URL (e.g. "https://fluxer.gg/abc123").
+   */
+  static normalizeCode(codeOrUrl) {
+    const input = codeOrUrl.trim();
+    if (!input) {
+      throw new RangeError("Invite code cannot be empty");
+    }
+    const parseAsUrl = (value) => {
+      try {
+        const url = new URL(value);
+        const segments = url.pathname.split("/").filter(Boolean);
+        if (segments.length === 0) {
+          return null;
+        }
+        const inviteSegmentIdx = segments.findIndex((segment) => {
+          const lower = segment.toLowerCase();
+          return lower === "invite" || lower === "invites";
+        });
+        const code2 = inviteSegmentIdx >= 0 && segments[inviteSegmentIdx + 1] ? segments[inviteSegmentIdx + 1] : segments[segments.length - 1];
+        return decodeURIComponent(code2).trim();
+      } catch {
+        return null;
+      }
+    };
+    const directCode = decodeURIComponent(input).trim();
+    const hasScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(input);
+    const fromAbsoluteUrl = parseAsUrl(input);
+    const fromHostLike = hasScheme ? null : parseAsUrl(`https://${input}`);
+    const code = fromAbsoluteUrl ?? fromHostLike ?? directCode;
+    if (!code || /[\s/?#]/.test(code)) {
+      throw new RangeError("Invalid invite code or URL");
+    }
+    return code;
+  }
+  /** @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;
+  }
+  /**
+   * Fetch invite information by code or URL.
+   * Does not consume or accept the invite.
+   */
+  static async fetch(client, codeOrUrl) {
+    const code = _Invite.normalizeCode(codeOrUrl);
+    const data = await client.rest.get(Routes4.invite(code));
+    return new _Invite(client, data);
+  }
+  /** 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(Routes4.invite(this.code), { auth: true });
+  }
+};
+
+// src/structures/Channel.ts
+var Channel = class _Channel extends Base {
+  /** Whether this channel has a send method (TextChannel, DMChannel). */
+  isTextBased() {
+    return "send" in this;
+  }
+  /** Whether this channel is a DM or Group DM. */
+  isDM() {
+    return this.type === ChannelType.DM || this.type === ChannelType.GroupDM;
+  }
+  /** Whether this channel is voice-based (VoiceChannel). */
+  isVoice() {
+    return "bitrate" in this;
+  }
+  isLink() {
+    return "url" in this;
+  }
+  /** Create a DM channel from API data (type DM or GroupDM). */
+  static createDM(client, data) {
+    return new DMChannel(client, data);
+  }
+  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.
+   * @param client - The client instance
+   * @param data - Channel data from the API
+   */
+  static from(client, data) {
+    const type = data.type ?? 0;
+    if (type === ChannelType.GuildText) return new TextChannel(client, data);
+    if (type === ChannelType.GuildCategory) return new CategoryChannel(client, data);
+    if (type === ChannelType.GuildVoice) return new VoiceChannel(client, data);
+    if (type === ChannelType.GuildLink || type === ChannelType.GuildLinkExtended)
+      return new LinkChannel(client, data);
+    return new GuildChannel(client, data);
+  }
+  /**
+   * Create a channel from API data, including DM and GroupDM.
+   * Used by ChannelManager.fetch() for GET /channels/{id}.
+   */
+  static fromOrCreate(client, data) {
+    const type = data.type ?? 0;
+    if (type === ChannelType.DM || type === 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(Routes5.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(Routes5.channelTyping(this.id), { auth: true });
+  }
+  /**
+   * Whether the bot can send messages in this channel.
+   * For DMs: always true (when the channel exists).
+   * For guild channels: checks ViewChannel and SendMessages permissions via guild.members.me.
+   */
+  canSendMessage() {
+    if (this.isDM()) return true;
+    return false;
+  }
+};
+var 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.
+   * @param options - Webhook name and optional avatar URL
+   * @returns The webhook with token (required for send()). Requires Manage Webhooks permission.
+   */
+  async createWebhook(options) {
+    const data = await this.client.rest.post(Routes5.channelWebhooks(this.id), {
+      body: options,
+      auth: true
+    });
+    return new Webhook(this.client, data);
+  }
+  /**
+   * Fetch all webhooks in this channel.
+   * @returns Webhooks (includes token when listing from channel; can send via send())
+   */
+  async fetchWebhooks() {
+    const data = await this.client.rest.get(Routes5.channelWebhooks(this.id));
+    const list = Array.isArray(data) ? data : Object.values(data ?? {});
+    return list.map((w) => new Webhook(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 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(Routes5.channelInvites(this.id), {
+      body: Object.keys(body).length ? body : void 0,
+      auth: true
+    });
+    return new Invite(this.client, data);
+  }
+  /**
+   * Fetch invites for this channel.
+   * Requires Manage Channel permission.
+   */
+  async fetchInvites() {
+    const data = await this.client.rest.get(Routes5.channelInvites(this.id));
+    const list = Array.isArray(data) ? data : Object.values(data ?? {});
+    return list.map((i) => new Invite(this.client, i));
+  }
+  /**
+   * Set or update a permission overwrite. PUT /channels/{id}/permissions/{overwriteId}.
+   * @param overwriteId - Role or member ID
+   * @param options - type (0=role, 1=member), allow, deny (permission bitfields)
+   */
+  async editPermission(overwriteId, options) {
+    await this.client.rest.put(Routes5.channelPermission(this.id, overwriteId), {
+      body: options,
+      auth: true
+    });
+    const idx = this.permissionOverwrites.findIndex((o) => o.id === overwriteId);
+    const entry = {
+      id: overwriteId,
+      type: options.type,
+      allow: options.allow ?? "0",
+      deny: options.deny ?? "0"
+    };
+    if (idx >= 0) this.permissionOverwrites[idx] = entry;
+    else this.permissionOverwrites.push(entry);
+  }
+  /**
+   * Whether the bot can send messages in this channel.
+   * Checks ViewChannel and SendMessages via guild.members.me permissions.
+   * Returns false if guild or bot member not cached.
+   */
+  canSendMessage() {
+    const guild = this.client.guilds.get(this.guildId);
+    if (!guild) return false;
+    const me = guild.members.me;
+    if (!me) return false;
+    const perms = me.permissionsIn(this);
+    return perms.has(PermissionFlags.ViewChannel) && perms.has(PermissionFlags.SendMessages);
+  }
+  /**
+   * Send a message to this guild channel.
+   * Works for text and announcement channels. Voice/category/link channels will fail at the API.
+   */
+  async send(options) {
+    const opts = typeof options === "string" ? { content: options } : options;
+    const body = buildSendBody(options);
+    const files = opts.files?.length ? await resolveMessageFiles(opts.files) : void 0;
+    const postOptions = files?.length ? { body, files } : { body };
+    const data = await this.client.rest.post(Routes5.channelMessages(this.id), postOptions);
+    this.client._addMessageToCache(this.id, data);
+    return new Message(this.client, data);
+  }
+  /**
+   * Remove a permission overwrite. DELETE /channels/{id}/permissions/{overwriteId}.
+   */
+  async deletePermission(overwriteId) {
+    await this.client.rest.delete(Routes5.channelPermission(this.id, overwriteId), { auth: true });
+    const idx = this.permissionOverwrites.findIndex((o) => o.id === overwriteId);
+    if (idx >= 0) this.permissionOverwrites.splice(idx, 1);
+  }
+  /**
+   * Edit this channel. PATCH /channels/{id}.
+   * Requires Manage Channel permission.
+   */
+  async edit(options) {
+    const data = await this.client.rest.patch(Routes5.channel(this.id), {
+      body: options,
+      auth: true
+    });
+    this.name = data.name ?? this.name;
+    this.parentId = data.parent_id ?? this.parentId;
+    this.permissionOverwrites = data.permission_overwrites ?? this.permissionOverwrites;
+    const self = this;
+    if ("topic" in self && "topic" in data) self.topic = data.topic ?? null;
+    if ("nsfw" in self && "nsfw" in data) self.nsfw = data.nsfw ?? false;
+    if ("rate_limit_per_user" in data) self.rateLimitPerUser = data.rate_limit_per_user ?? 0;
+    if ("bitrate" in self && "bitrate" in data) self.bitrate = data.bitrate ?? null;
+    if ("user_limit" in data) self.userLimit = data.user_limit ?? null;
+    if ("rtc_region" in data) self.rtcRegion = data.rtc_region ?? null;
+    return this;
+  }
+  /**
+   * Delete this channel. Requires Manage Channel permission.
+   * @param options - silent: if true, does not send a system message (default false)
+   */
+  async delete(options) {
+    const url = Routes5.channel(this.id) + (options?.silent ? "?silent=true" : "");
+    await this.client.rest.delete(url, { auth: true });
+    this.client.channels.delete(this.id);
+    const guild = this.client.guilds.get(this.guildId);
+    if (guild) guild.channels.delete(this.id);
+  }
+};
+var TextChannel = class extends GuildChannel {
+  topic;
+  nsfw;
+  rateLimitPerUser;
+  lastMessageId;
+  constructor(client, data) {
+    super(client, data);
+    this.topic = data.topic ?? null;
+    this.nsfw = data.nsfw ?? false;
+    this.rateLimitPerUser = data.rate_limit_per_user ?? 0;
+    this.lastMessageId = data.last_message_id ?? null;
+  }
+  /**
+   * Send a message to this channel.
+   * @param options - Text content or object with content, embeds, and/or files
+   */
+  async send(options) {
+    const opts = typeof options === "string" ? { content: options } : options;
+    const body = buildSendBody(options);
+    const files = opts.files?.length ? await resolveMessageFiles(opts.files) : void 0;
+    const postOptions = files?.length ? { body, files } : { body };
+    const data = await this.client.rest.post(Routes5.channelMessages(this.id), postOptions);
+    this.client._addMessageToCache(this.id, data);
+    return new Message(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 data = await this.client.rest.get(Routes5.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 Message(this.client, msg);
+    });
+  }
+  /**
+   * Fetch a message by ID from this channel.
+   * @param messageId - Snowflake of the message
+   * @returns The message, or null if not found
+   * @deprecated Use channel.messages.fetch(messageId) instead.
+   */
+  async fetchMessage(messageId) {
+    emitDeprecationWarning(
+      "Channel.fetchMessage()",
+      "Use channel.messages.fetch(messageId) instead."
+    );
+    return this.client.channels.fetchMessage(this.id, messageId);
+  }
+};
+var CategoryChannel = class extends GuildChannel {
+};
+var VoiceChannel = class extends GuildChannel {
+  bitrate;
+  userLimit;
+  rtcRegion;
+  constructor(client, data) {
+    super(client, data);
+    this.bitrate = data.bitrate ?? null;
+    this.userLimit = data.user_limit ?? null;
+    this.rtcRegion = data.rtc_region ?? null;
+  }
+};
+var LinkChannel = class extends GuildChannel {
+  url;
+  constructor(client, data) {
+    super(client, data);
+    this.url = data.url ?? null;
+  }
+};
+var 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, embeds, and/or files
+   */
+  async send(options) {
+    const opts = typeof options === "string" ? { content: options } : options;
+    const body = buildSendBody(options);
+    const files = opts.files?.length ? await resolveMessageFiles(opts.files) : void 0;
+    const postOptions = files?.length ? { body, files } : { body };
+    const data = await this.client.rest.post(Routes5.channelMessages(this.id), postOptions);
+    this.client._addMessageToCache(this.id, data);
+    return new Message(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 data = await this.client.rest.get(Routes5.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 Message(this.client, msg);
+    });
+  }
+  /**
+   * Fetch a message by ID from this DM channel.
+   * @param messageId - Snowflake of the message
+   * @returns The message, or null if not found
+   * @deprecated Use channel.messages.fetch(messageId) instead.
+   */
+  async fetchMessage(messageId) {
+    emitDeprecationWarning(
+      "Channel.fetchMessage()",
+      "Use channel.messages.fetch(messageId) instead."
+    );
+    return this.client.channels.fetchMessage(this.id, messageId);
+  }
+  /**
+   * Add a recipient to this Group DM. Requires Group DM (type GroupDM).
+   * PUT /channels/{id}/recipients/{userId}.
+   */
+  async addRecipient(userId) {
+    await this.client.rest.put(Routes5.channelRecipient(this.id, userId), { auth: true });
+    const user = this.client.users.get(userId) ?? await this.client.users.fetch(userId);
+    if (user) this.recipients.push(user);
+  }
+  /**
+   * Remove a recipient from this Group DM. Requires Group DM (type GroupDM).
+   * DELETE /channels/{id}/recipients/{userId}.
+   * @param options - silent: if true, does not send a system message (default false)
+   */
+  async removeRecipient(userId, options) {
+    const url = Routes5.channelRecipient(this.id, userId) + (options?.silent ? "?silent=true" : "");
+    await this.client.rest.delete(url, { auth: true });
+    const idx = this.recipients.findIndex((u) => u.id === userId);
+    if (idx >= 0) this.recipients.splice(idx, 1);
+  }
+};
+
+// src/client/ChannelManager.ts
+var ChannelManager = class extends Collection4 {
+  constructor(client) {
+    super();
+    this.client = client;
+    this.maxSize = client.options?.cache?.channels ?? 0;
+  }
+  maxSize;
+  set(key, value) {
+    if (this.maxSize > 0 && this.size >= this.maxSize && !this.has(key)) {
+      const firstKey = this.keys().next().value;
+      if (firstKey !== void 0) this.delete(firstKey);
+    }
+    return super.set(key, value);
+  }
+  /**
+   * Get a channel from cache or fetch from the API if not present.
+   * Convenience helper to avoid repeating `client.channels.get(id) ?? (await client.channels.fetch(id))`.
+   * @param channelId - Snowflake of the channel
+   * @returns The channel
+   * @throws FluxerError with CHANNEL_NOT_FOUND if the channel does not exist
+   * @example
+   * const channel = await client.channels.resolve(message.channelId);
+   * if (channel?.isTextBased()) await channel.send('Hello!');
+   */
+  async resolve(channelId) {
+    return this.get(channelId) ?? this.fetch(channelId);
+  }
+  /**
+   * Fetch a channel by ID from the API (or return from cache if present).
+   * @param channelId - Snowflake of the channel
+   * @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?.isTextBased()) await channel.send('Hello!');
+   */
+  async fetch(channelId) {
+    const cached = this.get(channelId);
+    if (cached) return cached;
+    try {
+      const data = await this.client.rest.get(Routes6.channel(channelId));
+      const channel = Channel.fromOrCreate(this.client, data);
+      if (!channel) {
+        throw new FluxerError("Channel data invalid or unsupported type", {
+          code: ErrorCodes.ChannelNotFound
+        });
+      }
+      this.set(channel.id, channel);
+      if ("guildId" in channel) {
+        const guild = this.client.guilds.get(channel.guildId);
+        if (guild) guild.channels.set(channel.id, channel);
+      }
+      return channel;
+    } catch (err) {
+      if (err instanceof RateLimitError2) throw err;
+      if (err instanceof FluxerAPIError2 && 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
+   * @throws FluxerError with MESSAGE_NOT_FOUND if the message does not exist
+   * @deprecated Use channel.messages.fetch(messageId). Prefer (await client.channels.resolve(channelId))?.messages?.fetch(messageId).
+   * @example
+   * const channel = await client.channels.resolve(channelId);
+   * const message = await channel?.messages?.fetch(messageId);
+   */
+  async fetchMessage(channelId, messageId) {
+    emitDeprecationWarning2(
+      "ChannelManager.fetchMessage()",
+      "Use channel.messages.fetch(messageId). Prefer (await client.channels.resolve(channelId))?.messages?.fetch(messageId)."
+    );
+    try {
+      const data = await this.client.rest.get(
+        Routes6.channelMessage(channelId, messageId)
+      );
+      return new Message(this.client, data);
+    } catch (err) {
+      if (err instanceof RateLimitError2) throw err;
+      if (err instanceof FluxerAPIError2 && 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, embeds, and/or files
+   * @returns The created message
+   * @example
+   * await client.channels.send(logChannelId, 'User joined!');
+   * await client.channels.send(channelId, { embeds: [embed] });
+   * await client.channels.send(channelId, { content: 'Report', files: [{ name: 'log.txt', data }] });
+   */
+  async send(channelId, payload) {
+    const opts = typeof payload === "string" ? { content: payload } : payload;
+    const body = buildSendBody(payload);
+    const files = opts.files?.length ? await resolveMessageFiles(opts.files) : void 0;
+    const postOptions = files?.length ? { body, files } : { body };
+    const data = await this.client.rest.post(Routes6.channelMessages(channelId), postOptions);
+    this.client._addMessageToCache(channelId, data);
+    return new Message(this.client, data);
+  }
+};
+
+// src/client/GuildManager.ts
+import { Collection as Collection8 } from "@erinjs/collection";
+import { Routes as Routes15 } from "@erinjs/types";
+
+// src/structures/Guild.ts
+import {
+  parseRoleMention,
+  resolvePermissionsToBitfield as resolvePermissionsToBitfield2
+} from "@erinjs/util";
+import { FluxerAPIError as FluxerAPIError3 } from "@erinjs/rest";
+import { Collection as Collection7 } from "@erinjs/collection";
+
+// src/client/GuildMemberManager.ts
+import { Collection as Collection6 } from "@erinjs/collection";
+import { Routes as Routes9 } from "@erinjs/types";
+
+// src/structures/GuildMember.ts
+import { BitField } from "@erinjs/util";
+import { Routes as Routes8 } from "@erinjs/types";
+
+// src/util/permissions.ts
+import { OverwriteType } from "@erinjs/types";
+import { ALL_PERMISSIONS_BIGINT, PermissionFlags as PermissionFlags2 } from "@erinjs/util";
+function computePermissions(basePermissions, overwrites, memberRoles, memberId, isOwner) {
+  if (isOwner) return ALL_PERMISSIONS_BIGINT;
+  let perms = basePermissions;
+  for (const overwrite of overwrites ?? []) {
+    const applies = overwrite.type === OverwriteType.Role && memberRoles.includes(overwrite.id) || overwrite.type === 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 & PermissionFlags2.Administrator) !== 0n ? ALL_PERMISSIONS_BIGINT : perms;
+}
+
+// src/structures/GuildMemberRoleManager.ts
+import { Collection as Collection5 } from "@erinjs/collection";
+import { Routes as Routes7 } from "@erinjs/types";
+var GuildMemberRoleManager = class {
+  constructor(member, initialRoleIds = []) {
+    this.member = member;
+    this._roleIds = [...initialRoleIds];
+  }
+  _roleIds = [];
+  /** Role IDs for this member. Used by permissions; prefer cache for Role objects. */
+  get roleIds() {
+    return this._roleIds;
+  }
+  /** Check if the member has a role. Discord.js parity: member.roles.cache.has(roleId) */
+  has(roleOrId) {
+    return this._roleIds.includes(this._resolveId(roleOrId));
+  }
+  /**
+   * Collection of Role objects for this member's roles (from guild.roles).
+   * Discord.js parity: member.roles.cache
+   * @discordJsCompat https://discord.js.org/docs/packages/discord.js/main/GuildMemberRoleManager
+   */
+  get cache() {
+    const coll = new Collection5();
+    for (const id of this._roleIds) {
+      const role = this.member.guild.roles.get(id);
+      if (role) coll.set(id, role);
+    }
+    return coll;
+  }
+  /** Resolve role ID from RoleResolvable. */
+  _resolveId(roleOrId) {
+    return typeof roleOrId === "string" ? roleOrId : roleOrId.id;
+  }
+  /**
+   * Add a role to this member.
+   * Discord.js parity: member.roles.add(roleId)
+   * Requires Manage Roles permission.
+   * @discordJsCompat https://discord.js.org/docs/packages/discord.js/main/GuildMemberRoleManager
+   */
+  async add(roleOrId) {
+    const roleId = this._resolveId(roleOrId);
+    if (this._roleIds.includes(roleId)) return;
+    await this.member.client.rest.put(
+      Routes7.guildMemberRole(this.member.guild.id, this.member.id, roleId)
+    );
+    this._roleIds.push(roleId);
+  }
+  /**
+   * Remove a role from this member.
+   * Discord.js parity: member.roles.remove(roleId)
+   * Requires Manage Roles permission.
+   * @discordJsCompat https://discord.js.org/docs/packages/discord.js/main/GuildMemberRoleManager
+   */
+  async remove(roleOrId) {
+    const roleId = this._resolveId(roleOrId);
+    const idx = this._roleIds.indexOf(roleId);
+    if (idx === -1) return;
+    await this.member.client.rest.delete(
+      Routes7.guildMemberRole(this.member.guild.id, this.member.id, roleId)
+    );
+    this._roleIds.splice(idx, 1);
+  }
+  /**
+   * Replace all roles for this member. PATCH /guilds/{id}/members/{userId}
+   * Discord.js parity: member.roles.set(roleIds)
+   * Requires Manage Roles permission.
+   * @discordJsCompat https://discord.js.org/docs/packages/discord.js/main/GuildMemberRoleManager
+   */
+  async set(roleIds) {
+    const data = await this.member.client.rest.patch(
+      Routes7.guildMember(this.member.guild.id, this.member.id),
+      { body: { roles: roleIds }, auth: true }
+    );
+    this._roleIds = data.roles ? [...data.roles] : [];
+  }
+  /**
+   * Update internal role IDs from API response. Called by GuildMember.edit().
+   * @internal
+   */
+  _patch(roleIds) {
+    this._roleIds = [...roleIds];
+  }
+};
+
+// src/structures/GuildMember.ts
+var GuildMember = class extends Base {
+  client;
+  id;
+  user;
+  guild;
+  nick;
+  /**
+   * Role manager with add/remove/set and cache. Discord.js parity: member.roles.add(), member.roles.cache
+   * @discordJsCompat https://discord.js.org/docs/packages/discord.js/main/GuildMemberRoleManager
+   */
+  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();
+    this.client = client;
+    this.user = client.getOrCreateUser(data.user);
+    this.id = data.user.id;
+    this.guild = guild;
+    this.nick = data.nick ?? null;
+    this.roles = new GuildMemberRoleManager(this, 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.
+   * Prefer member.roles.add(roleId) for Discord.js parity.
+   * @param roleId - The role ID to add
+   * Requires Manage Roles permission.
+   */
+  async addRole(roleId) {
+    await this.roles.add(roleId);
+  }
+  /**
+   * Remove a role from this member.
+   * Prefer member.roles.remove(roleId) for Discord.js parity.
+   * @param roleId - The role ID to remove
+   * Requires Manage Roles permission.
+   */
+  async removeRole(roleId) {
+    await this.roles.remove(roleId);
+  }
+  /**
+   * Edit this guild member. PATCH /guilds/{id}/members/{userId} or /members/@me for the bot.
+   * For @me: nick, avatar, banner, bio, pronouns, accent_color, profile_flags, mute, deaf,
+   * communication_disabled_until, timeout_reason, channel_id, connection_id.
+   * For other members: same plus roles (array of role IDs).
+   */
+  async edit(options) {
+    const isMe = this.client.user?.id === this.id;
+    const route = isMe ? `/guilds/${this.guild.id}/members/@me` : Routes8.guildMember(this.guild.id, this.id);
+    const data = await this.client.rest.patch(route, {
+      body: options,
+      auth: true
+    });
+    this.nick = data.nick ?? this.nick;
+    if (data.roles) this.roles._patch(data.roles);
+    if (data.communication_disabled_until != null) {
+      this.communicationDisabledUntil = data.communication_disabled_until ? new Date(data.communication_disabled_until) : null;
+    }
+    return this;
+  }
+  /**
+   * 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 new BitField(perms);
+  }
+  /**
+   * 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.roleIds],
+      this.id,
+      isOwner
+    );
+    return new BitField(perms);
+  }
+  /**
+   * Move this member to a different voice channel or disconnect them from voice.
+   * Requires Move Members permission.
+   * @param channelId - The voice channel ID to move the member to, or null to disconnect
+   * @param connectionId - Optional connection ID for the specific voice session (usually not needed)
+   * @returns Promise that resolves when the member has been moved
+   * @example
+   * // Move member to a different voice channel
+   * await member.move('123456789012345678');
+   *
+   * // Disconnect member from voice
+   * await member.move(null);
+   */
+  async move(channelId, connectionId) {
+    await this.edit({
+      channel_id: channelId,
+      connection_id: connectionId
+    });
+  }
+  _computeBasePermissions() {
+    let base = 0n;
+    const everyone = this.guild.roles.get(this.guild.id);
+    if (everyone) base |= everyone.permissions.bitfield;
+    for (const roleId of this.roles.roleIds) {
+      if (roleId === this.guild.id) continue;
+      const role = this.guild.roles.get(roleId);
+      if (role) base |= role.permissions.bitfield;
+    }
+    return base;
+  }
+};
+
+// src/client/GuildMemberManager.ts
+var GuildMemberManager = class extends Collection6 {
+  constructor(guild) {
+    super();
+    this.guild = guild;
+  }
+  /**
+   * Get a guild member from cache or fetch from the API if not present.
+   * Convenience helper to avoid repeating `guild.members.get(userId) ?? (await guild.fetchMember(userId))`.
+   * @param userId - Snowflake of the user
+   * @returns The guild member
+   * @throws FluxerError with MEMBER_NOT_FOUND if user is not in the guild (404)
+   * @example
+   * const member = await guild.members.resolve(userId);
+   * console.log(member.displayName);
+   */
+  async resolve(userId) {
+    return this.get(userId) ?? this.guild.fetchMember(userId);
+  }
+  /**
+   * The current bot user as a GuildMember in this guild.
+   * Returns null if the bot's member is not cached or client.user is null.
+   * Use fetchMe() to load the bot's member when not cached.
+   *
+   * @discordJsCompat https://discord.js.org/docs/packages/discord.js/main/GuildMemberManager
+   * @example
+   * const perms = guild.members.me?.permissions;
+   * if (perms?.has(PermissionFlags.BanMembers)) { ... }
+   */
+  get me() {
+    const userId = this.guild.client.user?.id;
+    return userId ? this.get(userId) ?? null : null;
+  }
+  /**
+   * Fetch the current bot user as a GuildMember in this guild.
+   * Caches the result in guild.members.
+   *
+   * @throws Error if client.user is null (client not ready)
+   * @example
+   * const me = await guild.members.fetchMe();
+   * console.log(me.displayName);
+   */
+  async fetchMe() {
+    const userId = this.guild.client.user?.id;
+    if (!userId) {
+      throw new Error("Cannot fetch me: client.user is null (client not ready)");
+    }
+    return this.guild.fetchMember(userId);
+  }
+  /**
+   * Fetch guild members with pagination. GET /guilds/{id}/members.
+   * @param options - limit (1-1000), after (user ID for pagination)
+   * @returns Array of GuildMember objects (cached in guild.members)
+   */
+  async fetch(options) {
+    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 url = Routes9.guildMembers(this.guild.id) + (qs ? `?${qs}` : "");
+    const data = await this.guild.client.rest.get(url, { auth: true });
+    const list = Array.isArray(data) ? data : data?.members ?? [];
+    const members = [];
+    for (const m of list) {
+      const member = new GuildMember(
+        this.guild.client,
+        { ...m, guild_id: this.guild.id },
+        this.guild
+      );
+      this.set(member.id, member);
+      members.push(member);
+    }
+    return members;
+  }
+};
+
+// src/structures/Role.ts
+import { Routes as Routes10 } from "@erinjs/types";
+import {
+  PermissionFlags as PermissionFlags4,
+  resolvePermissionsToBitfield,
+  ALL_PERMISSIONS_BIGINT as ALL_PERMISSIONS_BIGINT2,
+  PermissionsBitField
+} from "@erinjs/util";
+var Role = class extends Base {
+  client;
+  id;
+  guildId;
+  name;
+  color;
+  position;
+  _permissions;
+  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 */
+  constructor(client, data, guildId) {
+    super();
+    this.client = client;
+    this.id = data.id;
+    this.guildId = guildId;
+    this.name = data.name;
+    this.color = data.color;
+    this.position = data.position;
+    this._permissions = data.permissions;
+    this.hoist = !!data.hoist;
+    this.mentionable = !!data.mentionable;
+    this.unicodeEmoji = data.unicode_emoji ?? null;
+    this.hoistPosition = data.hoist_position ?? null;
+  }
+  get permissions() {
+    const bits = BigInt(this._permissions);
+    return new PermissionsBitField(
+      (bits & PermissionFlags4.Administrator) !== 0n ? ALL_PERMISSIONS_BIGINT2 : bits
+    );
+  }
+  /** Update mutable fields from fresh API data. Used by edit and gateway events. */
+  _patch(data) {
+    if (data.name !== void 0) this.name = data.name;
+    if (data.color !== void 0) this.color = data.color;
+    if (data.position !== void 0) this.position = data.position;
+    if (data.permissions !== void 0) this._permissions = data.permissions;
+    if (data.hoist !== void 0) this.hoist = !!data.hoist;
+    if (data.mentionable !== void 0) this.mentionable = !!data.mentionable;
+    if (data.unicode_emoji !== void 0) this.unicodeEmoji = data.unicode_emoji ?? null;
+    if (data.hoist_position !== void 0) this.hoistPosition = data.hoist_position ?? null;
+  }
+  /** Returns a mention string (e.g. `<@&123456>`). */
+  toString() {
+    return `<@&${this.id}>`;
+  }
+  /**
+   * Edit this role.
+   * Requires Manage Roles permission.
+   * @param options - Role updates (permissions accepts PermissionResolvable for convenience)
+   * @returns This role (updated in place)
+   * @example
+   * await role.edit({ name: 'Moderator', permissions: ['BanMembers', 'KickMembers'] });
+   */
+  async edit(options) {
+    const body = {};
+    if (options.name !== void 0) body.name = options.name;
+    if (options.permissions !== void 0) {
+      body.permissions = typeof options.permissions === "string" ? options.permissions : resolvePermissionsToBitfield(options.permissions);
+    }
+    if (options.color !== void 0) body.color = options.color;
+    if (options.hoist !== void 0) body.hoist = options.hoist;
+    if (options.mentionable !== void 0) body.mentionable = options.mentionable;
+    if (options.unicode_emoji !== void 0) body.unicode_emoji = options.unicode_emoji;
+    if (options.position !== void 0) body.position = options.position;
+    if (options.hoist_position !== void 0) body.hoist_position = options.hoist_position;
+    const data = await this.client.rest.patch(Routes10.guildRole(this.guildId, this.id), {
+      body: Object.keys(body).length ? body : void 0,
+      auth: true
+    });
+    this._patch(data);
+    return this;
+  }
+  /**
+   * Delete this role.
+   * Requires Manage Roles permission.
+   */
+  async delete() {
+    await this.client.rest.delete(Routes10.guildRole(this.guildId, this.id), { auth: true });
+    const guild = this.client.guilds.get(this.guildId);
+    if (guild) guild.roles.delete(this.id);
+  }
+};
+
+// src/structures/Guild.ts
+import { Routes as Routes14 } from "@erinjs/types";
+
+// src/structures/GuildBan.ts
+import { Routes as Routes11 } from "@erinjs/types";
+var 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(Routes11.guildBan(this.guildId, this.user.id), {
+      auth: true
+    });
+  }
+};
+
+// src/structures/GuildEmoji.ts
+import { Routes as Routes12 } from "@erinjs/types";
+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(Routes12.guildEmoji(this.guildId, this.id), {
+      auth: true
+    });
+    const guild = this.client.guilds.get(this.guildId);
+    if (guild) guild.emojis.delete(this.id);
+  }
+  /**
+   * Edit this emoji's name.
+   * Requires Manage Emojis and Stickers permission.
+   */
+  async edit(options) {
+    const data = await this.client.rest.patch(Routes12.guildEmoji(this.guildId, this.id), {
+      body: options,
+      auth: true
+    });
+    this.name = data.name;
+    return this;
+  }
+};
+
+// src/structures/GuildSticker.ts
+import { Routes as Routes13 } from "@erinjs/types";
+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(Routes13.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(Routes13.guildSticker(this.guildId, this.id), {
+      body: options,
+      auth: true
+    });
+    const s = data;
+    this.name = s.name;
+    this.description = s.description ?? "";
+    return this;
+  }
+};
+
+// src/structures/Guild.ts
+var Guild = class extends Base {
+  client;
+  id;
+  name;
+  icon;
+  banner;
+  ownerId;
+  /** 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;
+  channels = new Collection7();
+  roles = new Collection7();
+  emojis = new Collection7();
+  stickers = new Collection7();
+  /** @param data - API guild from GET /guilds/{id} or gateway GUILD_CREATE */
+  constructor(client, data) {
+    super();
+    this.client = client;
+    this.id = data.id;
+    this.members = new GuildMemberManager(this);
+    this.name = data.name;
+    this.icon = data.icon ?? null;
+    this.banner = data.banner ?? null;
+    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));
+    }
+  }
+  /** Get the guild icon URL, or null if no icon. */
+  iconURL(options) {
+    if (!this.icon) return null;
+    const size = options?.size ? `?size=${options.size}` : "";
+    return `${CDN_URL}/icons/${this.id}/${this.icon}.png${size}`;
+  }
+  /** Get the guild banner URL, or null if no banner. */
+  bannerURL(options) {
+    if (!this.banner) return null;
+    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
+   * @param roleId - The role ID to add (or use guild.resolveRoleId for mention/name resolution)
+   * Requires Manage Roles permission.
+   */
+  async addRoleToMember(userId, roleId) {
+    await this.client.rest.put(Routes14.guildMemberRole(this.id, userId, roleId));
+  }
+  /**
+   * Remove a role from a member by user ID. Does not require fetching the member first.
+   * @param userId - The user ID of the member
+   * @param roleId - The role ID to remove
+   * Requires Manage Roles permission.
+   */
+  async removeRoleFromMember(userId, roleId) {
+    await this.client.rest.delete(Routes14.guildMemberRole(this.id, userId, roleId));
+  }
+  /**
+   * Create a role in this guild.
+   * Requires Manage Roles permission.
+   * @param options - Role data (permissions accepts PermissionResolvable for convenience)
+   * @returns The created role
+   * @example
+   * const role = await guild.createRole({ name: 'Mod', permissions: ['KickMembers', 'BanMembers'] });
+   */
+  async createRole(options) {
+    const body = {};
+    if (options.name !== void 0) body.name = options.name;
+    if (options.permissions !== void 0) {
+      body.permissions = typeof options.permissions === "string" ? options.permissions : resolvePermissionsToBitfield2(options.permissions);
+    }
+    if (options.color !== void 0) body.color = options.color;
+    if (options.hoist !== void 0) body.hoist = options.hoist;
+    if (options.mentionable !== void 0) body.mentionable = options.mentionable;
+    if (options.unicode_emoji !== void 0) body.unicode_emoji = options.unicode_emoji;
+    if (options.position !== void 0) body.position = options.position;
+    if (options.hoist_position !== void 0) body.hoist_position = options.hoist_position;
+    const data = await this.client.rest.post(Routes14.guildRoles(this.id), {
+      body: Object.keys(body).length ? body : void 0,
+      auth: true
+    });
+    const role = new Role(this.client, data, this.id);
+    this.roles.set(role.id, role);
+    return role;
+  }
+  /**
+   * Fetch all roles in this guild.
+   * @returns Array of Role objects (cached in guild.roles)
+   */
+  async fetchRoles() {
+    const data = await this.client.rest.get(
+      Routes14.guildRoles(this.id)
+    );
+    const list = Array.isArray(data) ? data : Object.values(data ?? {});
+    const roles = [];
+    for (const r of list) {
+      const role = new Role(this.client, r, this.id);
+      this.roles.set(role.id, role);
+      roles.push(role);
+    }
+    return roles;
+  }
+  /**
+   * Fetch a role by ID.
+   * @param roleId - The role ID to fetch
+   * @returns The role
+   * @throws FluxerError with ROLE_NOT_FOUND if role does not exist (404)
+   */
+  async fetchRole(roleId) {
+    try {
+      const data = await this.client.rest.get(Routes14.guildRole(this.id, roleId));
+      const role = new Role(this.client, data, this.id);
+      this.roles.set(role.id, role);
+      return role;
+    } catch (err) {
+      const statusCode = err instanceof FluxerAPIError3 ? err.statusCode : err?.statusCode;
+      if (statusCode === 404) {
+        throw new FluxerError(`Role ${roleId} not found in guild`, {
+          code: ErrorCodes.RoleNotFound,
+          cause: err
+        });
+      }
+      throw err instanceof FluxerError ? err : new FluxerError("Failed to fetch guild role", { cause: err });
+    }
+  }
+  /**
+   * Resolve a role ID from an argument (role mention, raw ID, or name).
+   * Fetches guild roles if name is provided.
+   * @param arg - Role mention (@role), role ID, or role name
+   * @returns The role ID, or null if not found
+   */
+  async resolveRoleId(arg) {
+    const parsed = 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(Routes14.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) {
+      this.roles.set(role.id, new Role(this.client, role, this.id));
+      return role.id;
+    }
+    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(Routes14.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 data = await this.client.rest.get(
+      Routes14.guildBans(this.id)
+    );
+    const list = Array.isArray(data) ? data : data?.bans ?? [];
+    return list.map((b) => new GuildBan(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(Routes14.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(Routes14.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
+   * @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(
+        Routes14.guildMember(this.id, userId)
+      );
+      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 FluxerAPIError3 ? 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 = Routes14.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 data = await this.client.rest.get(Routes14.guildWebhooks(this.id));
+    const list = Array.isArray(data) ? data : Object.values(data ?? {});
+    return list.map((w) => new Webhook(this.client, w));
+  }
+  /**
+   * Fetch all invites in this guild.
+   * Requires Manage Guild permission.
+   */
+  async fetchInvites() {
+    const data = await this.client.rest.get(
+      Routes14.guildInvites(this.id)
+    );
+    const list = Array.isArray(data) ? data : Object.values(data ?? {});
+    return list.map((invite) => new Invite(this.client, invite));
+  }
+  /**
+   * Fetch a guild invite by code or URL.
+   * Convenience wrapper for Invite.fetch(client, codeOrUrl).
+   */
+  async fetchInvite(codeOrUrl) {
+    return Invite.fetch(this.client, codeOrUrl);
+  }
+  /**
+   * 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 created = await this.client.rest.post(Routes14.guildChannels(this.id), {
+      body: data,
+      auth: true
+    });
+    const channel = Channel.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 data = await this.client.rest.get(Routes14.guildChannels(this.id));
+    const list = Array.isArray(data) ? data : Object.values(data ?? {});
+    const channels = [];
+    for (const ch of list) {
+      const channel = Channel.from(this.client, ch);
+      if (channel) {
+        this.client.channels.set(channel.id, channel);
+        this.channels.set(channel.id, channel);
+        channels.push(channel);
+      }
+    }
+    return channels;
+  }
+  /**
+   * Edit this guild. PATCH /guilds/{id}.
+   * Requires guild owner or Administrator.
+   */
+  async edit(options) {
+    const data = await this.client.rest.patch(Routes14.guild(this.id), {
+      body: options,
+      auth: true
+    });
+    this.name = data.name;
+    this.icon = data.icon ?? this.icon;
+    this.banner = data.banner ?? this.banner;
+    this.splash = data.splash ?? this.splash;
+    this.systemChannelId = data.system_channel_id ?? this.systemChannelId;
+    this.afkChannelId = data.afk_channel_id ?? this.afkChannelId;
+    this.afkTimeout = data.afk_timeout ?? this.afkTimeout;
+    this.verificationLevel = data.verification_level ?? this.verificationLevel;
+    this.mfaLevel = data.mfa_level ?? this.mfaLevel;
+    this.explicitContentFilter = data.explicit_content_filter ?? this.explicitContentFilter;
+    this.defaultMessageNotifications = data.default_message_notifications ?? this.defaultMessageNotifications;
+    this.features = data.features ?? this.features;
+    return this;
+  }
+  /**
+   * Delete this guild. POST /guilds/{id}/delete.
+   * Must be the guild owner.
+   */
+  async delete() {
+    await this.client.rest.post(Routes14.guildDelete(this.id), { auth: true });
+    this.client.guilds.delete(this.id);
+  }
+  /**
+   * Fetch vanity URL for this guild. GET /guilds/{id}/vanity-url.
+   * Requires Manage Guild permission.
+   */
+  async fetchVanityURL() {
+    return this.client.rest.get(Routes14.guildVanityUrl(this.id), { auth: true });
+  }
+  /**
+   * Transfer guild ownership to another user. POST /guilds/{id}/transfer-ownership.
+   * Must be the guild owner.
+   */
+  async transferOwnership(newOwnerId, password) {
+    await this.client.rest.post(Routes14.guildTransferOwnership(this.id), {
+      body: { new_owner_id: newOwnerId, ...password != null && { password } },
+      auth: true
+    });
+  }
+  /**
+   * Set text channel flexible names feature. PATCH /guilds/{id}/text-channel-flexible-names.
+   */
+  setTextChannelFlexibleNames(enabled) {
+    return this.client.rest.patch(Routes14.guildTextChannelFlexibleNames(this.id), {
+      body: { enabled },
+      auth: true
+    }).then(() => this);
+  }
+  /**
+   * Set detached banner feature. PATCH /guilds/{id}/detached-banner.
+   */
+  setDetachedBanner(enabled) {
+    return this.client.rest.patch(Routes14.guildDetachedBanner(this.id), {
+      body: { enabled },
+      auth: true
+    }).then(() => this);
+  }
+  /**
+   * Set disallow unclaimed accounts. PATCH /guilds/{id}/disallow-unclaimed-accounts.
+   */
+  setDisallowUnclaimedAccounts(enabled) {
+    return this.client.rest.patch(Routes14.guildDisallowUnclaimedAccounts(this.id), {
+      body: { enabled },
+      auth: true
+    }).then(() => this);
+  }
+  /**
+   * Update role positions. PATCH /guilds/{id}/roles.
+   * @param updates - Array of { id, position? }
+   */
+  async setRolePositions(updates) {
+    const data = await this.client.rest.patch(
+      Routes14.guildRoles(this.id),
+      { body: updates, auth: true }
+    );
+    const list = Array.isArray(data) ? data : Object.values(data ?? {});
+    for (const r of list) {
+      this.roles.set(r.id, new Role(this.client, r, this.id));
+    }
+    return list;
+  }
+  /**
+   * Update role hoist positions. PATCH /guilds/{id}/roles/hoist-positions.
+   */
+  async setRoleHoistPositions(updates) {
+    const data = await this.client.rest.patch(
+      Routes14.guildRolesHoistPositions(this.id),
+      { body: updates, auth: true }
+    );
+    const list = Array.isArray(data) ? data : Object.values(data ?? {});
+    for (const r of list) {
+      this.roles.set(r.id, new Role(this.client, r, this.id));
+    }
+    return list;
+  }
+  /**
+   * Reset role hoist positions. DELETE /guilds/{id}/roles/hoist-positions.
+   */
+  async resetRoleHoistPositions() {
+    const data = await this.client.rest.delete(
+      Routes14.guildRolesHoistPositions(this.id),
+      { auth: true }
+    );
+    const list = Array.isArray(data) ? data : Object.values(data ?? {});
+    for (const r of list) {
+      this.roles.set(r.id, new Role(this.client, r, this.id));
+    }
+    return list;
+  }
+  /**
+   * 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(Routes14.guildChannels(this.id), {
+      body: updates,
+      auth: true
+    });
+  }
+  /**
+   * Fetch all emojis in this guild.
+   * @returns Array of GuildEmoji objects (cached in guild.emojis)
+   */
+  async fetchEmojis() {
+    const data = await this.client.rest.get(
+      Routes14.guildEmojis(this.id)
+    );
+    const list = Array.isArray(data) ? data : Object.values(data ?? {});
+    const emojis = [];
+    for (const e of list) {
+      const emoji = new GuildEmoji(this.client, { ...e, guild_id: this.id }, this.id);
+      this.emojis.set(emoji.id, emoji);
+      emojis.push(emoji);
+    }
+    return emojis;
+  }
+  /**
+   * Fetch a single emoji by ID.
+   * @param emojiId - The emoji ID to fetch
+   * @returns The guild emoji
+   * @throws FluxerError if emoji not found (404)
+   */
+  async fetchEmoji(emojiId) {
+    try {
+      const data = await this.client.rest.get(Routes14.guildEmoji(this.id, emojiId));
+      const emoji = new GuildEmoji(this.client, { ...data, guild_id: this.id }, this.id);
+      this.emojis.set(emoji.id, emoji);
+      return emoji;
+    } catch (err) {
+      const statusCode = err instanceof FluxerAPIError3 ? err.statusCode : err?.statusCode;
+      if (statusCode === 404) {
+        throw new FluxerError(`Emoji ${emojiId} not found in guild`, {
+          code: ErrorCodes.EmojiNotFound,
+          cause: err
+        });
+      }
+      throw err instanceof FluxerError ? err : new FluxerError("Failed to fetch guild emoji", { cause: err });
+    }
+  }
+  /**
+   * Fetch all stickers in this guild.
+   * @returns Array of GuildSticker objects (cached in guild.stickers)
+   */
+  async fetchStickers() {
+    const data = await this.client.rest.get(
+      Routes14.guildStickers(this.id)
+    );
+    const list = Array.isArray(data) ? data : Object.values(data ?? {});
+    const stickers = [];
+    for (const s of list) {
+      const sticker = new GuildSticker(this.client, { ...s, guild_id: this.id }, this.id);
+      this.stickers.set(sticker.id, sticker);
+      stickers.push(sticker);
+    }
+    return stickers;
+  }
+  /**
+   * Fetch a single sticker by ID.
+   * @param stickerId - The sticker ID to fetch
+   */
+  async fetchSticker(stickerId) {
+    const data = await this.client.rest.get(Routes14.guildSticker(this.id, stickerId));
+    const sticker = new GuildSticker(this.client, { ...data, guild_id: this.id }, this.id);
+    this.stickers.set(sticker.id, sticker);
+    return sticker;
+  }
+  /**
+   * Bulk create emojis. POST /guilds/{id}/emojis/bulk.
+   * @param emojis - Array of { name, image } (base64), 1-50 emojis
+   * @returns Array of created GuildEmoji objects
+   */
+  async createEmojisBulk(emojis) {
+    const data = await this.client.rest.post(
+      Routes14.guildEmojisBulk(this.id),
+      {
+        body: { emojis },
+        auth: true
+      }
+    );
+    const list = Array.isArray(data) ? data : data?.emojis ?? [];
+    return list.map((e) => new GuildEmoji(this.client, { ...e, guild_id: this.id }, this.id));
+  }
+  /**
+   * Bulk create stickers. POST /guilds/{id}/stickers/bulk.
+   * @param stickers - Array of { name, image, description?, tags? }, 1-50 stickers
+   * @returns Array of created GuildSticker objects
+   */
+  async createStickersBulk(stickers) {
+    const data = await this.client.rest.post(
+      Routes14.guildStickersBulk(this.id),
+      {
+        body: { stickers },
+        auth: true
+      }
+    );
+    const list = Array.isArray(data) ? data : data?.stickers ?? [];
+    const created = list.map(
+      (s) => new GuildSticker(this.client, { ...s, guild_id: this.id }, this.id)
+    );
+    for (const sticker of created) {
+      this.stickers.set(sticker.id, sticker);
+    }
+    return created;
+  }
+};
+
+// src/client/GuildManager.ts
+var GuildManager = class extends Collection8 {
+  constructor(client) {
+    super();
+    this.client = client;
+    this.maxSize = client.options?.cache?.guilds ?? 0;
+  }
+  maxSize;
+  set(key, value) {
+    if (this.maxSize > 0 && this.size >= this.maxSize && !this.has(key)) {
+      const firstKey = this.keys().next().value;
+      if (firstKey !== void 0) this.delete(firstKey);
+    }
+    return super.set(key, value);
+  }
+  /**
+   * Get a guild from cache or fetch from the API if not present.
+   * Convenience helper to avoid repeating `client.guilds.get(id) ?? (await client.guilds.fetch(id))`.
+   * @param guildId - Snowflake of the guild
+   * @returns The guild, or null if not found
+   * @example
+   * const guild = await client.guilds.resolve(message.guildId);
+   * if (guild) console.log(guild.name);
+   */
+  async resolve(guildId) {
+    return this.get(guildId) ?? this.fetch(guildId);
+  }
+  /**
+   * Create a guild. POST /guilds.
+   * @param options - name (required), icon (base64), empty_features
+   * @returns The created guild
+   */
+  async create(options) {
+    const data = await this.client.rest.post(Routes15.guilds(), {
+      body: options,
+      auth: true
+    });
+    const guild = new Guild(this.client, data);
+    this.set(guild.id, guild);
+    return guild;
+  }
+  /**
+   * Fetch a guild by ID from the API (or return from cache if present).
+   * @param guildId - Snowflake of the guild
+   * @returns The guild, or null if not found
+   * @example
+   * const guild = await client.guilds.fetch(guildId);
+   * if (guild) console.log(guild.name);
+   */
+  async fetch(guildId) {
+    const cached = this.get(guildId);
+    if (cached) return cached;
+    try {
+      const data = await this.client.rest.get(Routes15.guild(guildId));
+      const guild = new Guild(this.client, data);
+      this.set(guild.id, guild);
+      return guild;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/structures/User.ts
+import { Routes as Routes16 } from "@erinjs/types";
+var User = class extends Base {
+  client;
+  id;
+  username;
+  discriminator;
+  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();
+    this.client = client;
+    this.id = data.id;
+    this.username = data.username;
+    this.discriminator = data.discriminator;
+    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) {
+    this.username = data.username;
+    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.
+   * 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 = 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}`;
+  }
+  /** Get the avatar URL, or the default avatar if none set (Fluxer: fluxerstatic.com). */
+  displayAvatarURL(options) {
+    return this.avatarURL(options) ?? cdnDefaultAvatarURL(this.id);
+  }
+  /**
+   * 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}>`;
+  }
+  /**
+   * Create or get a DM channel with this user.
+   * Returns the DM channel; use {@link DMChannel.send} to send messages.
+   */
+  async createDM() {
+    const data = await this.client.rest.post(Routes16.userMeChannels(), {
+      body: { recipient_id: this.id },
+      auth: true
+    });
+    return new DMChannel(this.client, data);
+  }
+  /**
+   * Send a DM to this user.
+   * Convenience method that creates the DM channel and sends the message.
+   */
+  async send(options) {
+    const dm = await this.createDM();
+    return dm.send(options);
+  }
+};
+
+// src/client/ClientUser.ts
+import { Routes as Routes17 } from "@erinjs/types";
+var 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 data = await this.client.rest.get(
+      Routes17.currentUserGuilds()
+    );
+    const list = Array.isArray(data) ? data : data?.guilds ?? [];
+    const guilds = [];
+    for (const g of list) {
+      const guild = new Guild(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(Routes17.leaveGuild(guildId), { auth: true });
+    this.client.guilds.delete(guildId);
+  }
+};
+
+// src/client/Client.ts
+import {
+  emitDeprecationWarning as emitDeprecationWarning3,
+  formatEmoji,
+  getUnicodeFromShortcode,
+  parseEmoji
+} from "@erinjs/util";
+
+// src/client/UsersManager.ts
+import { Collection as Collection9 } from "@erinjs/collection";
+import { Routes as Routes18 } from "@erinjs/types";
+var UsersManager = class extends Collection9 {
+  constructor(client) {
+    super();
+    this.client = client;
+    this.maxSize = client.options?.cache?.users ?? 0;
+  }
+  maxSize;
+  set(key, value) {
+    if (this.maxSize > 0 && this.size >= this.maxSize && !this.has(key)) {
+      const firstKey = this.keys().next().value;
+      if (firstKey !== void 0) this.delete(firstKey);
+    }
+    return super.set(key, value);
+  }
+  /**
+   * Fetch a user by ID from the API.
+   * Updates cache if user already exists.
+   * @param userId - Snowflake of the user
+   * @returns The user
+   * @throws FluxerError (or REST error) if user not found
+   * @example
+   * const user = await client.users.fetch(userId);
+   * console.log(user.username);
+   */
+  async fetch(userId) {
+    const data = await this.client.rest.get(Routes18.user(userId));
+    return this.client.getOrCreateUser(data);
+  }
+  /**
+   * Fetch a user with full profile and optional guild context.
+   * Returns user, global profile, server profile (when guildId), and member (when guildId).
+   * Ideal for userinfo commands.
+   * @param userId - Snowflake of the user
+   * @param options - Optional guildId for server profile and member data
+   * @returns User, raw data, profiles, and member (when in guild)
+   * @throws FluxerError (or REST error) if user not found
+   * @example
+   * const { user, globalProfile, serverProfile, member } = await client.users.fetchWithProfile(
+   *   userId,
+   *   { guildId: message.guildId ?? undefined },
+   * );
+   */
+  async fetchWithProfile(userId, options) {
+    const guildId = options?.guildId ?? void 0;
+    const [userData, globalProfileData, serverProfileData, memberData] = await Promise.all([
+      this.client.rest.get(Routes18.user(userId)),
+      this.client.rest.get(Routes18.userProfile(userId)).catch(() => null),
+      guildId ? this.client.rest.get(Routes18.userProfile(userId, guildId)).catch(() => null) : Promise.resolve(null),
+      guildId ? this.client.rest.get(Routes18.guildMember(guildId, userId)).catch(() => null) : Promise.resolve(null)
+    ]);
+    const user = this.client.getOrCreateUser(userData);
+    const globalProfile = globalProfileData && typeof globalProfileData === "object" ? globalProfileData : null;
+    const serverProfile = serverProfileData && typeof serverProfileData === "object" ? serverProfileData : null;
+    let member = null;
+    if (memberData && guildId) {
+      const guild = this.client.guilds.get(guildId) ?? await this.client.guilds.fetch(guildId);
+      if (guild) {
+        member = new GuildMember(this.client, { ...memberData, guild_id: guildId }, guild);
+        guild.members.set(member.id, member);
+      }
+    }
+    return {
+      user,
+      userData,
+      globalProfile,
+      serverProfile,
+      member,
+      memberData
+    };
+  }
+};
+
+// src/util/guildUtils.ts
+function normalizeGuildPayload(raw) {
+  if (!raw || typeof raw !== "object") {
+    return null;
+  }
+  if ("properties" in raw && raw.properties != null && typeof raw.properties === "object") {
+    const r = raw;
+    return {
+      ...r.properties,
+      roles: r.roles
+    };
+  }
+  return raw;
+}
+
+// src/structures/MessageReaction.ts
+import { Routes as Routes19 } from "@erinjs/types";
+import { FluxerAPIError as FluxerAPIError4, RateLimitError as RateLimitError3 } from "@erinjs/rest";
+var MessageReaction = class extends Base {
+  client;
+  messageId;
+  channelId;
+  guildId;
+  emoji;
+  /** Raw gateway payload for low-level access. */
+  _data;
+  constructor(client, data) {
+    super();
+    this.client = client;
+    this._data = data;
+    this.messageId = data.message_id;
+    this.channelId = data.channel_id;
+    this.guildId = data.guild_id ?? null;
+    this.emoji = data.emoji;
+  }
+  /** Emoji as a string: unicode or "name:id" for custom. */
+  get emojiIdentifier() {
+    return this.emoji.id ? `${this.emoji.name}:${this.emoji.id}` : this.emoji.name;
+  }
+  /** Guild where this reaction was added. Resolved from cache; null for DMs or if not cached. */
+  get guild() {
+    return this.guildId ? this.client.guilds.get(this.guildId) ?? null : null;
+  }
+  /**
+   * 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() {
+    try {
+      const data = await this.client.rest.get(
+        Routes19.channelMessage(this.channelId, this.messageId)
+      );
+      return new Message(this.client, data);
+    } catch (err) {
+      if (err instanceof RateLimitError3) throw err;
+      if (err instanceof FluxerAPIError4 && err.statusCode === 404) {
+        throw new FluxerError(`Message ${this.messageId} not found in channel ${this.channelId}`, {
+          code: ErrorCodes.MessageNotFound,
+          cause: err
+        });
+      }
+      throw err instanceof FluxerError ? err : new FluxerError(String(err), { cause: err });
+    }
+  }
+};
+
+// src/client/EventHandlerRegistry.ts
+var handlers = /* @__PURE__ */ new Map();
+function normalizeInviteCreatePayload(client, payload) {
+  if (!payload?.code) return null;
+  const guildId = payload.guild?.id ?? payload.guild_id ?? "0";
+  const cachedGuild = guildId !== "0" ? client.guilds.get(guildId) : null;
+  const guild = {
+    id: guildId,
+    name: payload.guild?.name ?? cachedGuild?.name ?? "Unknown Guild",
+    icon: payload.guild?.icon ?? null,
+    banner: payload.guild?.banner ?? null,
+    splash: payload.guild?.splash ?? null,
+    features: payload.guild?.features
+  };
+  const channelId = payload.channel?.id ?? payload.channel_id ?? "0";
+  const cachedChannel = channelId !== "0" ? client.channels.get(channelId) : null;
+  const channel = {
+    id: channelId,
+    type: payload.channel?.type ?? cachedChannel?.type ?? 0,
+    name: payload.channel?.name ?? cachedChannel?.name ?? null,
+    icon: payload.channel?.icon ?? null
+  };
+  return {
+    code: payload.code,
+    type: typeof payload.type === "number" ? payload.type : 0,
+    guild,
+    channel,
+    inviter: payload.inviter ?? null,
+    member_count: payload.member_count,
+    presence_count: payload.presence_count,
+    expires_at: payload.expires_at,
+    temporary: payload.temporary,
+    created_at: payload.created_at,
+    uses: payload.uses,
+    max_uses: payload.max_uses,
+    max_age: payload.max_age
+  };
+}
+handlers.set("MESSAGE_CREATE", async (client, d) => {
+  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 GuildMember(client, memberData, guild);
+      guild.members.set(member.id, member);
+    }
+  }
+  client._addMessageToCache(data.channel_id, data);
+  client.emit(Events.MessageCreate, new Message(client, data));
+});
+handlers.set("MESSAGE_UPDATE", async (client, d) => {
+  const partial = d;
+  const cache = client._getMessageCache(partial.channel_id);
+  let oldMessage = null;
+  let mergedData = partial;
+  if (cache) {
+    const oldData = cache.get(partial.id);
+    if (oldData) {
+      oldMessage = new Message(client, oldData);
+      mergedData = { ...oldData, ...partial };
+    }
+    cache.set(partial.id, mergedData);
+  }
+  const newMessage = new Message(client, mergedData);
+  client.emit(Events.MessageUpdate, oldMessage, newMessage);
+});
+handlers.set("MESSAGE_DELETE", async (client, d) => {
+  const data = d;
+  client._removeMessageFromCache(data.channel_id, data.id);
+  const channel = client.channels.get(data.channel_id) ?? null;
+  client.emit(Events.MessageDelete, {
+    id: data.id,
+    channelId: data.channel_id,
+    channel,
+    content: data.content ?? null,
+    authorId: data.author_id ?? null
+  });
+});
+handlers.set("MESSAGE_REACTION_ADD", async (client, d) => {
+  const data = d;
+  const reaction = new MessageReaction(client, data);
+  const user = client.getOrCreateUser({
+    id: data.user_id,
+    username: "Unknown",
+    discriminator: "0"
+  });
+  client.emit(Events.MessageReactionAdd, reaction, user);
+});
+handlers.set("MESSAGE_REACTION_REMOVE", async (client, d) => {
+  const data = d;
+  const reaction = new MessageReaction(client, data);
+  const user = client.getOrCreateUser({
+    id: data.user_id,
+    username: "Unknown",
+    discriminator: "0"
+  });
+  client.emit(Events.MessageReactionRemove, reaction, user);
+});
+handlers.set("MESSAGE_REACTION_REMOVE_ALL", async (client, d) => {
+  client.emit(Events.MessageReactionRemoveAll, d);
+});
+handlers.set("MESSAGE_REACTION_REMOVE_EMOJI", async (client, d) => {
+  client.emit(
+    Events.MessageReactionRemoveEmoji,
+    d
+  );
+});
+handlers.set("GUILD_CREATE", async (client, d) => {
+  const guildData = normalizeGuildPayload(d);
+  if (!guildData) return;
+  const guild = new Guild(client, guildData);
+  client.guilds.set(guild.id, guild);
+  const g = d;
+  for (const ch of g.channels ?? []) {
+    const channel = Channel.from(client, ch);
+    if (channel) {
+      client.channels.set(channel.id, channel);
+      guild.channels.set(channel.id, channel);
+    }
+  }
+  for (const m of g.members ?? []) {
+    if (m?.user?.id) {
+      const memberData = { ...m, guild_id: guild.id };
+      const member = new GuildMember(client, memberData, guild);
+      guild.members.set(member.id, member);
+    }
+  }
+  client.emit(Events.GuildCreate, guild);
+  if (g.voice_states?.length) {
+    client.emit(Events.VoiceStatesSync, { guildId: guild.id, voiceStates: g.voice_states });
+  }
+  client._onGuildReceived(guild.id);
+});
+handlers.set("GUILD_UPDATE", async (client, d) => {
+  const guildData = normalizeGuildPayload(d);
+  if (!guildData) return;
+  const old = client.guilds.get(guildData.id);
+  const updated = new Guild(client, guildData);
+  client.guilds.set(updated.id, updated);
+  client.emit(Events.GuildUpdate, old ?? updated, updated);
+});
+handlers.set("GUILD_DELETE", async (client, d) => {
+  const g = d;
+  const guild = client.guilds.get(g.id);
+  if (guild) {
+    client.guilds.delete(g.id);
+    client.emit(Events.GuildDelete, guild);
+  }
+});
+handlers.set("CHANNEL_CREATE", async (client, d) => {
+  const ch = Channel.from(client, d);
+  if (ch) {
+    client.channels.set(ch.id, ch);
+    if ("guildId" in ch && ch.guildId) {
+      const guild = client.guilds.get(ch.guildId);
+      if (guild) guild.channels.set(ch.id, ch);
+    }
+    client.emit(Events.ChannelCreate, ch);
+  }
+});
+handlers.set("CHANNEL_UPDATE", async (client, d) => {
+  const ch = d;
+  const oldCh = client.channels.get(ch.id);
+  const newCh = Channel.from(client, ch);
+  if (newCh) {
+    client.channels.set(newCh.id, newCh);
+    if ("guildId" in newCh && newCh.guildId) {
+      const guild = client.guilds.get(newCh.guildId);
+      if (guild) guild.channels.set(newCh.id, newCh);
+    }
+    client.emit(Events.ChannelUpdate, oldCh ?? newCh, newCh);
+  }
+});
+handlers.set("CHANNEL_DELETE", async (client, d) => {
+  const ch = d;
+  const channel = client.channels.get(ch.id);
+  if (channel) {
+    if ("guildId" in channel && channel.guildId) {
+      const guild = client.guilds.get(channel.guildId);
+      if (guild) guild.channels.delete(channel.id);
+    }
+    client.channels.delete(ch.id);
+    client.emit(Events.ChannelDelete, channel);
+  }
+});
+handlers.set("GUILD_MEMBER_ADD", async (client, d) => {
+  const data = d;
+  const guild = client.guilds.get(data.guild_id);
+  if (guild) {
+    const member = new GuildMember(client, data, guild);
+    guild.members.set(member.id, member);
+    client.emit(Events.GuildMemberAdd, member);
+  }
+});
+handlers.set("GUILD_MEMBER_UPDATE", async (client, d) => {
+  const data = d;
+  const guild = client.guilds.get(data.guild_id);
+  if (guild) {
+    const oldM = guild.members.get(data.user.id);
+    const newM = new GuildMember(client, data, guild);
+    guild.members.set(newM.id, newM);
+    client.emit(Events.GuildMemberUpdate, oldM ?? newM, newM);
+  }
+});
+handlers.set("GUILD_MEMBER_REMOVE", async (client, d) => {
+  const data = d;
+  const guild = client.guilds.get(data.guild_id);
+  if (!guild || !data.user?.id) return;
+  let member = guild.members.get(data.user.id);
+  if (member) {
+    guild.members.delete(data.user.id);
+  } else {
+    const user = {
+      ...data.user,
+      id: data.user.id,
+      username: data.user.username ?? "Unknown",
+      discriminator: data.user.discriminator ?? "0"
+    };
+    const memberData = {
+      user,
+      roles: [],
+      joined_at: (/* @__PURE__ */ new Date(0)).toISOString(),
+      nick: null
+    };
+    member = new GuildMember(client, memberData, guild);
+  }
+  client.emit(Events.GuildMemberRemove, member);
+});
+handlers.set("GUILD_MEMBERS_CHUNK", async (client, d) => {
+  const data = d;
+  const guild = client.guilds.get(data.guild_id);
+  if (guild) {
+    for (const m of data.members ?? []) {
+      if (m?.user?.id) {
+        const memberData = { ...m, guild_id: guild.id };
+        const member = new GuildMember(client, memberData, guild);
+        guild.members.set(member.id, member);
+      }
+    }
+  }
+  client.emit(Events.GuildMembersChunk, data);
+});
+handlers.set("INTERACTION_CREATE", async (client, d) => {
+  client.emit(Events.InteractionCreate, d);
+});
+handlers.set("VOICE_STATE_UPDATE", async (client, d) => {
+  client.emit(Events.VoiceStateUpdate, d);
+});
+handlers.set("VOICE_SERVER_UPDATE", async (client, d) => {
+  client.emit(Events.VoiceServerUpdate, d);
+});
+handlers.set("MESSAGE_DELETE_BULK", async (client, d) => {
+  const data = d;
+  for (const id of data.ids ?? []) {
+    client._removeMessageFromCache(data.channel_id, id);
+  }
+  client.emit(Events.MessageDeleteBulk, data);
+});
+handlers.set("GUILD_BAN_ADD", async (client, d) => {
+  const data = d;
+  const banData = {
+    user: data.user,
+    reason: data.reason ?? null,
+    guild_id: data.guild_id
+  };
+  const ban = new GuildBan(client, banData, data.guild_id);
+  client.emit(Events.GuildBanAdd, ban);
+});
+handlers.set("GUILD_BAN_REMOVE", async (client, d) => {
+  const data = d;
+  const ban = new GuildBan(client, { ...data, reason: null }, data.guild_id);
+  client.emit(Events.GuildBanRemove, ban);
+});
+handlers.set("GUILD_EMOJIS_UPDATE", async (client, d) => {
+  const data = d;
+  const guild = client.guilds.get(data.guild_id);
+  if (guild) {
+    guild.emojis.clear();
+    for (const e of data.emojis ?? []) {
+      if (!e.id || e.name == null) continue;
+      guild.emojis.set(
+        e.id,
+        new GuildEmoji(
+          client,
+          { id: e.id, name: e.name, animated: e.animated ?? false, guild_id: guild.id },
+          guild.id
+        )
+      );
+    }
+  }
+  client.emit(Events.GuildEmojisUpdate, d);
+});
+handlers.set("GUILD_STICKERS_UPDATE", async (client, d) => {
+  client.emit(Events.GuildStickersUpdate, d);
+});
+handlers.set("GUILD_INTEGRATIONS_UPDATE", async (client, d) => {
+  client.emit(Events.GuildIntegrationsUpdate, d);
+});
+handlers.set("GUILD_ROLE_CREATE", async (client, d) => {
+  const data = d;
+  const guild = client.guilds.get(data.guild_id);
+  if (guild) {
+    guild.roles.set(data.role.id, new Role(client, data.role, guild.id));
+  }
+  client.emit(Events.GuildRoleCreate, data);
+});
+handlers.set("GUILD_ROLE_UPDATE", async (client, d) => {
+  const data = d;
+  const guild = client.guilds.get(data.guild_id);
+  if (guild) {
+    const existing = guild.roles.get(data.role.id);
+    if (existing) {
+      existing._patch(data.role);
+    } else {
+      guild.roles.set(data.role.id, new Role(client, data.role, guild.id));
+    }
+  }
+  client.emit(Events.GuildRoleUpdate, data);
+});
+handlers.set("GUILD_ROLE_DELETE", async (client, d) => {
+  const data = d;
+  const guild = client.guilds.get(data.guild_id);
+  if (guild) guild.roles.delete(data.role_id);
+  client.emit(Events.GuildRoleDelete, data);
+});
+handlers.set("GUILD_SCHEDULED_EVENT_CREATE", async (client, d) => {
+  client.emit(Events.GuildScheduledEventCreate, d);
+});
+handlers.set("GUILD_SCHEDULED_EVENT_UPDATE", async (client, d) => {
+  client.emit(Events.GuildScheduledEventUpdate, d);
+});
+handlers.set("GUILD_SCHEDULED_EVENT_DELETE", async (client, d) => {
+  client.emit(Events.GuildScheduledEventDelete, d);
+});
+handlers.set("CHANNEL_PINS_UPDATE", async (client, d) => {
+  client.emit(Events.ChannelPinsUpdate, d);
+});
+handlers.set("INVITE_CREATE", async (client, d) => {
+  const data = normalizeInviteCreatePayload(client, d);
+  if (!data) {
+    client.emit(
+      Events.Debug,
+      "[Gateway] INVITE_CREATE payload had no invite code (documented as possibly empty)"
+    );
+    return;
+  }
+  client.emit(
+    Events.Debug,
+    `[Gateway] INVITE_CREATE code=${data.code} guild=${data.guild.id} channel=${data.channel.id}`
+  );
+  client.emit(Events.InviteCreate, new Invite(client, data));
+});
+handlers.set("INVITE_DELETE", async (client, d) => {
+  client.emit(Events.InviteDelete, d);
+});
+handlers.set("TYPING_START", async (client, d) => {
+  client.emit(Events.TypingStart, d);
+});
+handlers.set("USER_UPDATE", async (client, d) => {
+  const data = d;
+  if (client.user?.id === data.id) {
+    client.user._patch(data);
+  }
+  client.emit(Events.UserUpdate, data);
+});
+handlers.set("PRESENCE_UPDATE", async (client, d) => {
+  client.emit(Events.PresenceUpdate, d);
+});
+handlers.set("WEBHOOKS_UPDATE", async (client, d) => {
+  client.emit(Events.WebhooksUpdate, d);
+});
+handlers.set("RESUMED", async (client) => {
+  client.emit(Events.Resumed);
+});
+var eventHandlers = handlers;
+
+// src/client/Client.ts
+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 EventEmitter3 {
+  /** @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
+    });
+    Object.defineProperty(this.guilds, "cache", {
+      get: () => this.guilds,
+      configurable: true
+    });
+    Object.defineProperty(this.users, "cache", {
+      get: () => this.users,
+      configurable: true
+    });
+    this.rest = new REST({
+      api: options.rest?.api ?? "https://api.fluxer.app",
+      version: options.rest?.version ?? "1",
+      ...options.rest
+    });
+  }
+  rest;
+  guilds = new GuildManager(this);
+  channels = new ChannelManager(this);
+  users = new UsersManager(this);
+  /** 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;
+  /** When waitForGuilds, set of guild IDs we're waiting for GUILD_CREATE on. Null when not waiting. */
+  _pendingGuildIds = null;
+  /** Timeout for guild stream when READY has no guilds (gateway sends only GUILD_CREATE). Cleared in finally. */
+  _guildStreamSettleTimeout = null;
+  /** Per-channel message cache (channelId -> messageId -> APIMessage). Used when options.cache.messages > 0. */
+  _messageCaches = null;
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  /**
+   * Resolve an emoji argument to the API format (unicode or "name:id").
+   * Supports: <:name:id>, :name:, name:id, { name, id }, unicode.
+   * When id is missing (e.g. :name:), fetches guild emojis if guildId provided.
+   * When reacting in a guild channel, custom emojis must be from that guild.
+   * @param emoji - Emoji string or object
+   * @param guildId - Guild ID for resolving custom emoji by name (required when id is missing)
+   * @returns API-formatted string for reactions
+   */
+  async resolveEmoji(emoji, guildId) {
+    if (typeof emoji === "object" && emoji.id) {
+      if (guildId) {
+        await this.assertEmojiInGuild(emoji.id, guildId);
+      }
+      return formatEmoji({ name: emoji.name, id: emoji.id, animated: emoji.animated });
+    }
+    const parsed = parseEmoji(
+      typeof emoji === "string" ? emoji : emoji.id ? `:${emoji.name}:` : emoji.name
+    );
+    if (!parsed) throw new Error("Invalid emoji");
+    if (parsed.id) {
+      if (guildId) {
+        await this.assertEmojiInGuild(parsed.id, guildId);
+      }
+      return formatEmoji(parsed);
+    }
+    if (!/^\w+$/.test(parsed.name)) return parsed.name;
+    const unicodeFromShortcode = getUnicodeFromShortcode(parsed.name);
+    if (unicodeFromShortcode) return unicodeFromShortcode;
+    if (guildId) {
+      const emojis = await this.rest.get(Routes20.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 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.`
+      );
+    }
+    if (/^\w+$/.test(parsed.name)) {
+      throw new Error(
+        `Custom emoji ":${parsed.name}:" requires guild context. Use message.react() in a guild channel, or pass guildId to client.resolveEmoji().`
+      );
+    }
+    return parsed.name;
+  }
+  /**
+   * Asserts that a custom emoji (by id) belongs to the given guild.
+   * Used when reacting in guild channels to reject emojis from other servers.
+   * @throws FluxerError with EMOJI_NOT_IN_GUILD if the emoji is not in the guild
+   */
+  async assertEmojiInGuild(emojiId, guildId) {
+    const emojis = await this.rest.get(Routes20.guildEmojis(guildId));
+    const list = Array.isArray(emojis) ? emojis : Object.values(emojis ?? {});
+    const found = list.some((e) => e.id === emojiId);
+    if (!found) {
+      throw new FluxerError("Custom emoji is from another server. Use an emoji from this server.", {
+        code: ErrorCodes.EmojiNotInGuild
+      });
+    }
+  }
+  /**
+   * Fetch instance discovery info (API URL, gateway URL, features).
+   * Uses canonical GET /.well-known/fluxer.
+   * Does not require authentication.
+   */
+  async fetchInstance() {
+    return this.rest.get(Routes20.instanceDiscovery(), { auth: false });
+  }
+  /**
+   * Fetch gateway connection metadata (WebSocket URL, recommended shards, session limits).
+   * Uses authenticated GET /gateway/bot.
+   */
+  async fetchGatewayInfo() {
+    return this.rest.get(Routes20.gatewayBot());
+  }
+  /**
+   * 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
+   * @throws FluxerError with MESSAGE_NOT_FOUND if the message does not exist
+   * @deprecated Use channel.messages.fetch(messageId). For IDs-only: (await client.channels.resolve(channelId))?.messages?.fetch(messageId)
+   * @example
+   * const channel = await client.channels.resolve(channelId);
+   * const message = await channel?.messages?.fetch(messageId);
+   */
+  async fetchMessage(channelId, messageId) {
+    emitDeprecationWarning3(
+      "Client.fetchMessage()",
+      "Use channel.messages.fetch(messageId). For IDs-only: (await client.channels.resolve(channelId))?.messages?.fetch(messageId)"
+    );
+    return this.channels.fetchMessage(channelId, messageId);
+  }
+  /**
+   * Send a message to any channel by ID. Shorthand for client.channels.send().
+   * Works even when the channel is not cached.
+   * @deprecated Use client.channels.send(channelId, payload).
+   */
+  async sendToChannel(channelId, payload) {
+    emitDeprecationWarning3(
+      "Client.sendToChannel()",
+      "Use client.channels.send(channelId, payload)."
+    );
+    return this.channels.send(channelId, payload);
+  }
+  /**
+   * Get the message cache for a channel. Returns null if message caching is disabled.
+   * Used by MessageManager.get() and event handlers.
+   * @internal
+   */
+  _getMessageCache(channelId) {
+    const limit = this.options.cache?.messages ?? 0;
+    if (limit <= 0) return null;
+    if (!this._messageCaches) this._messageCaches = /* @__PURE__ */ new Map();
+    let cache = this._messageCaches.get(channelId);
+    if (!cache) {
+      cache = /* @__PURE__ */ new Map();
+      this._messageCaches.set(channelId, cache);
+    }
+    return cache;
+  }
+  /**
+   * Add a message to the channel cache. Evicts oldest (FIFO) when over limit.
+   * @internal
+   */
+  _addMessageToCache(channelId, data) {
+    const cache = this._getMessageCache(channelId);
+    if (!cache) return;
+    const limit = this.options.cache?.messages ?? 0;
+    if (limit > 0 && cache.size >= limit && !cache.has(data.id)) {
+      const firstKey = cache.keys().next().value;
+      if (firstKey !== void 0) cache.delete(firstKey);
+    }
+    cache.set(data.id, { ...data });
+  }
+  /**
+   * Remove a message from the channel cache.
+   * @internal
+   */
+  _removeMessageFromCache(channelId, messageId) {
+    this._messageCaches?.get(channelId)?.delete(messageId);
+  }
+  /**
+   * Get or create a User from API data. Caches in client.users.
+   * Updates existing user's username, avatar, etc. when fresh data is provided.
+   */
+  getOrCreateUser(data) {
+    const existing = this.users.get(data.id);
+    if (existing) {
+      existing._patch(data);
+      return existing;
+    }
+    const user = new User(this, data);
+    this.users.set(user.id, user);
+    return user;
+  }
+  /** WebSocket manager. Throws if not logged in. */
+  get ws() {
+    if (!this._ws) throw new Error("Client is not logged in");
+    return this._ws;
+  }
+  /**
+   * Send a payload to the gateway (e.g. Voice State Update).
+   * @param shardId - Shard ID (use 0 for single-shard)
+   * @param payload - Gateway payload to send
+   */
+  sendToGateway(shardId, payload) {
+    this.ws.send(shardId, payload);
+  }
+  async handleDispatch(payload) {
+    if (payload.op !== 0 || !payload.t) return;
+    const { t: event, d } = payload;
+    try {
+      const handler = eventHandlers.get(event);
+      if (handler) await handler(this, d);
+    } catch (err) {
+      this.emit(Events.Error, err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  /**
+   * Connect to the Fluxer gateway and authenticate.
+   * @param token - Bot token (e.g. from FLUXER_BOT_TOKEN)
+   */
+  async login(token) {
+    if (this._ws) {
+      throw new FluxerError("Client is already logged in. Call destroy() first.", {
+        code: ErrorCodes.AlreadyLoggedIn
+      });
+    }
+    this.rest.setToken(token);
+    let intents = this.options.intents ?? 0;
+    if (intents !== 0) {
+      if (!this.options.suppressIntentWarning) {
+        if (typeof process !== "undefined" && process.emitWarning) {
+          process.emitWarning("Fluxer does not support intents yet. Value has been set to 0.", {
+            type: "FluxerIntents"
+          });
+        } else {
+          console.warn("Fluxer does not support intents yet. Value has been set to 0.");
+        }
+      }
+      intents = 0;
+    }
+    this._ws = new WebSocketManager({
+      token,
+      intents,
+      presence: this.options.presence,
+      rest: { get: (route) => this.rest.get(route) },
+      version: this.options.rest?.version ?? "1",
+      WebSocket: this.options.WebSocket
+    });
+    this._ws.on("dispatch", ({ payload }) => {
+      this.handleDispatch(payload).catch(
+        (err) => this.emit(Events.Error, err instanceof Error ? err : new Error(String(err)))
+      );
+    });
+    this._ws.on(
+      "ready",
+      async ({
+        data
+      }) => {
+        this.user = new ClientUser(this, data.user);
+        const waitForGuilds = this.options.waitForGuilds === true;
+        const pending = waitForGuilds ? /* @__PURE__ */ new Set() : null;
+        for (const g of data.guilds ?? []) {
+          if (g.unavailable === true) {
+            if (pending !== null && g.id) pending.add(g.id);
+            continue;
+          }
+          const guildData = normalizeGuildPayload(g);
+          if (!guildData) continue;
+          const guild = new Guild(this, guildData);
+          this.guilds.set(guild.id, guild);
+          const withCh = g;
+          for (const ch of withCh.channels ?? []) {
+            const channel = Channel.from(this, ch);
+            if (channel) {
+              this.channels.set(channel.id, channel);
+              guild.channels.set(channel.id, channel);
+            }
+          }
+          if (withCh.voice_states?.length) {
+            this.emit(Events.VoiceStatesSync, {
+              guildId: guild.id,
+              voiceStates: withCh.voice_states
+            });
+          }
+        }
+        if (pending !== null && pending.size > 0) {
+          this._pendingGuildIds = pending;
+          return;
+        }
+        if (waitForGuilds && (data.guilds ?? []).length === 0) {
+          const GUILD_STREAM_SETTLE_MS = 500;
+          this._guildStreamSettleTimeout = setTimeout(() => {
+            this._guildStreamSettleTimeout = null;
+            this._finalizeReady();
+          }, GUILD_STREAM_SETTLE_MS);
+          return;
+        }
+        this._finalizeReady();
+      }
+    );
+    this._ws.on("error", ({ error }) => this.emit(Events.Error, error));
+    this._ws.on("debug", (msg) => this.emit(Events.Debug, msg));
+    await this._ws.connect();
+    return token;
+  }
+  /**
+   * Called when all guilds have been received (or immediately if not waiting).
+   * Sets readyAt, emits Ready, clears pending state.
+   */
+  _finalizeReady() {
+    this._pendingGuildIds = null;
+    this.readyAt = /* @__PURE__ */ new Date();
+    this.emit(Events.Ready);
+  }
+  /**
+   * Called by GUILD_CREATE handler when waitForGuilds is enabled.
+   * Removes guild from pending set; when empty, finalizes ready.
+   */
+  _onGuildReceived(guildId) {
+    const pending = this._pendingGuildIds;
+    if (pending === null) return;
+    pending.delete(guildId);
+    if (pending.size === 0) this._finalizeReady();
+  }
+  /** Disconnect from the gateway and clear cached data. */
+  async destroy() {
+    if (this._guildStreamSettleTimeout !== null) {
+      clearTimeout(this._guildStreamSettleTimeout);
+      this._guildStreamSettleTimeout = null;
+    }
+    if (this._ws) {
+      this._ws.destroy();
+      this._ws = null;
+    }
+    this.rest.setToken(null);
+    this.user = null;
+    this.readyAt = null;
+    this._pendingGuildIds = null;
+    this.guilds.clear();
+    this.channels.clear();
+    this.users.clear();
+  }
+  /** Returns true if the client has received Ready and `user` is set. */
+  isReady() {
+    return this.readyAt !== null && this.user !== null;
+  }
+  /**
+   * Throws if the client is not ready. Use before accessing client.user or other post-ready state.
+   * @throws FluxerError with CLIENT_NOT_READY if client has not received Ready yet
+   */
+  assertReady() {
+    if (!this.isReady()) {
+      throw new FluxerError(
+        "Client is not ready yet. Wait for the Ready event before accessing client.user.",
+        {
+          code: ErrorCodes.ClientNotReady
+        }
+      );
+    }
+  }
+  static get Routes() {
+    return Routes20;
+  }
+};
+
+// src/index.ts
+import { EmbedBuilder as EmbedBuilder3, MessagePayload, AttachmentBuilder } from "@erinjs/builders";
+import { Routes as Routes21, GatewayOpcodes, MessageAttachmentFlags } from "@erinjs/types";
+import { resolveTenorToImageUrl, parseUserMention, parsePrefixCommand } from "@erinjs/util";
+import {
+  PermissionsBitField as PermissionsBitField2,
+  PermissionFlags as PermissionFlags5,
+  resolvePermissionsToBitfield as resolvePermissionsToBitfield3,
+  UserFlagsBitField,
+  UserFlagsBits
+} from "@erinjs/util";
+export {
+  AttachmentBuilder,
+  Base,
+  CDN_URL,
+  CategoryChannel,
+  Channel,
+  ChannelManager,
+  Client,
+  ClientUser,
+  DMChannel,
+  EmbedBuilder3 as EmbedBuilder,
+  ErrorCodes,
+  Events,
+  FluxerError,
+  GatewayOpcodes,
+  Guild,
+  GuildBan,
+  GuildChannel,
+  GuildEmoji,
+  GuildMember,
+  GuildMemberManager,
+  GuildMemberRoleManager,
+  GuildSticker,
+  Invite,
+  LinkChannel,
+  Message,
+  MessageAttachmentFlags,
+  MessageCollector,
+  MessageManager,
+  MessagePayload,
+  MessageReaction,
+  PermissionFlags5 as PermissionFlags,
+  PermissionsBitField2 as PermissionsBitField,
+  ReactionCollector,
+  Role,
+  Routes21 as Routes,
+  STATIC_CDN_URL,
+  TextChannel,
+  User,
+  UserFlagsBitField,
+  UserFlagsBits,
+  UsersManager,
+  VoiceChannel,
+  Webhook,
+  cdnAvatarURL,
+  cdnBannerURL,
+  cdnDefaultAvatarURL,
+  cdnDisplayAvatarURL,
+  cdnMemberAvatarURL,
+  cdnMemberBannerURL,
+  parsePrefixCommand,
+  parseUserMention,
+  resolvePermissionsToBitfield3 as resolvePermissionsToBitfield,
+  resolveTenorToImageUrl
+};