@fluxerjs/core 1.2.0 → 1.2.2

package/dist/index.mjs

@@ -1,214 +1,2460 @@
-import {
-  GuildEmoji
-} from "./chunk-IHXSHE2Z.mjs";
-import {
-  GuildSticker
-} from "./chunk-KR26CBFE.mjs";
-import {
-  Guild,
-  GuildMemberManager
-} from "./chunk-YGXCMETR.mjs";
-import {
-  MessageReaction
-} from "./chunk-75ODDXY3.mjs";
-import {
-  ClientUser,
-  User
-} from "./chunk-U33GNMEZ.mjs";
-import {
-  Message,
-  ReactionCollector
-} from "./chunk-HVCL7QLT.mjs";
-import {
-  Webhook
-} from "./chunk-3JVE6RW7.mjs";
-import {
-  Invite
-} from "./chunk-QEXIYXXU.mjs";
-import {
-  CategoryChannel,
-  Channel,
-  DMChannel,
-  GuildChannel,
-  LinkChannel,
-  MessageCollector,
-  MessageManager,
-  TextChannel,
-  VoiceChannel
-} from "./chunk-IRDYSGQO.mjs";
-import {
-  ErrorCodes,
-  FluxerError
-} from "./chunk-6S3BDHBI.mjs";
-import {
-  Events
-} from "./chunk-AH7KYH2Z.mjs";
-import {
-  buildSendBody,
-  resolveMessageFiles
-} from "./chunk-VJDH54HJ.mjs";
-import {
-  GuildMember
-} from "./chunk-24E6OQID.mjs";
-import {
-  cdnAvatarURL,
-  cdnBannerURL,
-  cdnDefaultAvatarURL,
-  cdnDisplayAvatarURL,
-  cdnMemberAvatarURL,
-  cdnMemberBannerURL
-} from "./chunk-G6F6VL4O.mjs";
-import {
-  CDN_URL,
-  STATIC_CDN_URL
-} from "./chunk-BKPVGBOT.mjs";
-import {
-  Role
-} from "./chunk-2ZSMLDEI.mjs";
-import {
-  GuildBan
-} from "./chunk-UXIF75BV.mjs";
-import {
-  Base
-} from "./chunk-XNS4O6QJ.mjs";
-
 // src/client/Client.ts
-import { EventEmitter } from "events";
+import { EventEmitter as EventEmitter3 } from "events";
 import { REST } from "@fluxerjs/rest";
 import { WebSocketManager } from "@fluxerjs/ws";
-import { Routes as Routes4 } from "@fluxerjs/types";
+import {
+  Routes as Routes20
+} from "@fluxerjs/types";
 
 // src/client/ChannelManager.ts
+import { Collection as Collection4 } from "@fluxerjs/collection";
+import { Routes as Routes6 } from "@fluxerjs/types";
+import { emitDeprecationWarning as emitDeprecationWarning2 } from "@fluxerjs/util";
+import { FluxerAPIError as FluxerAPIError2, RateLimitError as RateLimitError2 } from "@fluxerjs/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 "@fluxerjs/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
+    }));
+  }
+  return result;
+}
+
+// src/client/MessageManager.ts
+import { Routes as Routes2 } from "@fluxerjs/types";
+import { FluxerAPIError, RateLimitError } from "@fluxerjs/rest";
+
+// src/structures/Base.ts
+var Base = class {
+};
+
+// src/structures/Message.ts
+import { Collection as Collection2 } from "@fluxerjs/collection";
+import { MessageType, Routes } from "@fluxerjs/types";
+import { EmbedBuilder as EmbedBuilder2 } from "@fluxerjs/builders";
+
+// src/util/ReactionCollector.ts
+import { EventEmitter } from "events";
 import { Collection } from "@fluxerjs/collection";
-import { Routes } from "@fluxerjs/types";
+
+// src/util/Events.ts
+var Events = {
+  Ready: "ready",
+  MessageCreate: "messageCreate",
+  MessageUpdate: "messageUpdate",
+  MessageDelete: "messageDelete",
+  MessageDeleteBulk: "messageDeleteBulk",
+  MessageReactionAdd: "messageReactionAdd",
+  MessageReactionRemove: "messageReactionRemove",
+  MessageReactionRemoveAll: "messageReactionRemoveAll",
+  MessageReactionRemoveEmoji: "messageReactionRemoveEmoji",
+  InteractionCreate: "interactionCreate",
+  GuildCreate: "guildCreate",
+  GuildUpdate: "guildUpdate",
+  GuildDelete: "guildDelete",
+  GuildBanAdd: "guildBanAdd",
+  GuildBanRemove: "guildBanRemove",
+  GuildEmojisUpdate: "guildEmojisUpdate",
+  GuildStickersUpdate: "guildStickersUpdate",
+  GuildIntegrationsUpdate: "guildIntegrationsUpdate",
+  GuildMemberAdd: "guildMemberAdd",
+  GuildMemberUpdate: "guildMemberUpdate",
+  GuildMemberRemove: "guildMemberRemove",
+  GuildRoleCreate: "guildRoleCreate",
+  GuildRoleUpdate: "guildRoleUpdate",
+  GuildRoleDelete: "guildRoleDelete",
+  GuildScheduledEventCreate: "guildScheduledEventCreate",
+  GuildScheduledEventUpdate: "guildScheduledEventUpdate",
+  GuildScheduledEventDelete: "guildScheduledEventDelete",
+  ChannelCreate: "channelCreate",
+  ChannelUpdate: "channelUpdate",
+  ChannelDelete: "channelDelete",
+  ChannelPinsUpdate: "channelPinsUpdate",
+  InviteCreate: "inviteCreate",
+  InviteDelete: "inviteDelete",
+  TypingStart: "typingStart",
+  UserUpdate: "userUpdate",
+  PresenceUpdate: "presenceUpdate",
+  VoiceStateUpdate: "voiceStateUpdate",
+  VoiceServerUpdate: "voiceServerUpdate",
+  VoiceStatesSync: "voiceStatesSync",
+  WebhooksUpdate: "webhooksUpdate",
+  Resumed: "resumed",
+  Error: "error",
+  Debug: "debug"
+};
+
+// src/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 files
+   * @example
+   * await message.reply('Pong!');
+   * await message.reply({ embeds: [embed] });
+   */
+  async reply(options) {
+    const payload = await _Message._createMessageBody(options, {
+      channel_id: this.channelId,
+      message_id: this.id,
+      guild_id: this.guildId ?? void 0
+    });
+    return this._send(payload);
+  }
+  /** Exposed for testing purposes, use Message.reply() or send() for normal use */
+  static async _createMessageBody(content, referenced_message) {
+    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;
+    return referenced_message ? { files, body: { ...base, referenced_message } } : { files, body: { ...base } };
+  }
+  async _send(payload) {
+    const data = await this.client.rest.post(
+      Routes.channelMessages(this.channelId),
+      payload
+    );
+    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;
+  }
+  /**
+   * Fetch a message by ID from this channel.
+   * @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)
+      );
+      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 "@fluxerjs/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 "@fluxerjs/types";
+import { PermissionFlags } from "@fluxerjs/util";
 import { emitDeprecationWarning } from "@fluxerjs/util";
-import { FluxerAPIError, RateLimitError } from "@fluxerjs/rest";
-var ChannelManager = class extends Collection {
-  constructor(client) {
+
+// src/structures/Webhook.ts
+import { Routes as Routes3 } from "@fluxerjs/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.maxSize = client.options?.cache?.channels ?? 0;
+    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;
+  }
+  /**
+   * 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 "@fluxerjs/types";
+var Invite = class extends Base {
+  client;
+  code;
+  type;
+  guild;
+  channel;
+  inviter;
+  memberCount;
+  presenceCount;
+  expiresAt;
+  temporary;
+  createdAt;
+  uses;
+  maxUses;
+  maxAge;
+  /** @param data - API invite from GET /invites/{code}, channel/guild invite list, or gateway INVITE_CREATE */
+  constructor(client, data) {
+    super();
+    this.client = client;
+    this.code = data.code;
+    this.type = data.type;
+    this.guild = data.guild;
+    this.channel = data.channel;
+    this.inviter = data.inviter ? client.getOrCreateUser(data.inviter) : null;
+    this.memberCount = data.member_count ?? null;
+    this.presenceCount = data.presence_count ?? null;
+    this.expiresAt = data.expires_at ?? null;
+    this.temporary = data.temporary ?? null;
+    this.createdAt = data.created_at ?? null;
+    this.uses = data.uses ?? null;
+    this.maxUses = data.max_uses ?? null;
+    this.maxAge = data.max_age ?? null;
+  }
+  /** Full invite URL (https://fluxer.gg/{code} or instance-specific). */
+  get url() {
+    return `https://fluxer.gg/${this.code}`;
+  }
+  /**
+   * Resolve the guild from cache if available.
+   * @returns The guild, or null if not cached
+   */
+  getGuild() {
+    return this.guild?.id ? this.client.guilds.get(this.guild.id) ?? null : null;
+  }
+  /**
+   * Delete this invite.
+   * Requires Manage Guild or Create Instant Invite permission.
+   */
+  async delete() {
+    await this.client.rest.delete(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);
+    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);
+    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);
+    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);
+    return new Message(this.client, data);
+  }
+};
+
+// src/client/GuildManager.ts
+import { Collection as Collection8 } from "@fluxerjs/collection";
+import { Routes as Routes15 } from "@fluxerjs/types";
+
+// src/structures/Guild.ts
+import {
+  parseRoleMention,
+  resolvePermissionsToBitfield as resolvePermissionsToBitfield2
+} from "@fluxerjs/util";
+import { FluxerAPIError as FluxerAPIError3 } from "@fluxerjs/rest";
+import { Collection as Collection7 } from "@fluxerjs/collection";
+
+// src/client/GuildMemberManager.ts
+import { Collection as Collection6 } from "@fluxerjs/collection";
+import { Routes as Routes9 } from "@fluxerjs/types";
+
+// src/structures/GuildMember.ts
+import { PermissionFlagsMap } from "@fluxerjs/util";
+import { Routes as Routes8 } from "@fluxerjs/types";
+
+// src/util/permissions.ts
+import { OverwriteType } from "@fluxerjs/types";
+import { ALL_PERMISSIONS_BIGINT } from "@fluxerjs/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;
+}
+function hasPermission(bitfield, permission) {
+  const Administrator = 1n << 3n;
+  if ((bitfield & Administrator) !== 0n) return true;
+  return (bitfield & permission) === permission;
+}
+
+// src/structures/GuildMemberRoleManager.ts
+import { Collection as Collection5 } from "@fluxerjs/collection";
+import { Routes as Routes7 } from "@fluxerjs/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 {
+      has(permission) {
+        const perm = typeof permission === "number" ? permission : PermissionFlagsMap[String(permission)];
+        if (perm === void 0) return false;
+        return hasPermission(perms, BigInt(perm));
+      }
+    };
+  }
+  /**
+   * Compute the member's effective permissions in a guild channel.
+   * Applies role permissions and channel overwrites.
+   * @param channel - The guild channel to check permissions for
+   * @returns Object with has(permission) to check specific permissions
+   * @example
+   * const perms = member.permissionsIn(channel);
+   * if (perms.has(PermissionFlags.SendMessages)) { ... }
+   */
+  permissionsIn(channel) {
+    const base = this._computeBasePermissions();
+    const ownerId = this.guild.ownerId;
+    const isOwner = ownerId != null && ownerId !== "" && String(ownerId) === String(this.id);
+    const perms = computePermissions(
+      base,
+      channel.permissionOverwrites,
+      [...this.roles.roleIds],
+      this.id,
+      isOwner
+    );
+    return {
+      has(permission) {
+        const perm = typeof permission === "number" ? permission : PermissionFlagsMap[String(permission)];
+        if (perm === void 0) return false;
+        return hasPermission(perms, BigInt(perm));
+      }
+    };
+  }
+  _computeBasePermissions() {
+    let base = 0n;
+    const everyone = this.guild.roles.get(this.guild.id);
+    if (everyone) base |= BigInt(everyone.permissions);
+    for (const roleId of this.roles.roleIds) {
+      if (roleId === this.guild.id) continue;
+      const role = this.guild.roles.get(roleId);
+      if (role) base |= BigInt(role.permissions);
+    }
+    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 "@fluxerjs/types";
+import {
+  PermissionFlags as PermissionFlags2,
+  resolvePermissionsToBitfield
+} from "@fluxerjs/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;
+  }
+  /** 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}>`;
+  }
+  /**
+   * Check if this role has a permission. Administrator grants all permissions.
+   * @param permission - Permission flag, name, or resolvable
+   * @returns true if the role has the permission
+   * @example
+   * if (role.has(PermissionFlags.BanMembers)) { ... }
+   * if (role.has('ManageChannels')) { ... }
+   */
+  has(permission) {
+    const perm = typeof permission === "number" ? permission : PermissionFlags2[permission];
+    if (perm === void 0) return false;
+    const permNum = Number(perm);
+    const rolePerms = BigInt(this.permissions);
+    const permBig = BigInt(permNum);
+    if (permBig < 0) return false;
+    if ((rolePerms & BigInt(PermissionFlags2.Administrator)) !== 0n) return true;
+    return (rolePerms & permBig) === permBig;
+  }
+  /**
+   * 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 "@fluxerjs/types";
+
+// src/structures/GuildBan.ts
+import { Routes as Routes11 } from "@fluxerjs/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 "@fluxerjs/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 "@fluxerjs/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();
+  /** @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 });
+    }
   }
-  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);
+  /**
+   * 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 super.set(key, value);
+    return null;
   }
   /**
-   * 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?.isSendable()) await channel.send('Hello!');
+   * 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 resolve(channelId) {
-    return this.get(channelId) ?? this.fetch(channelId);
+  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 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?.isSendable()) await channel.send('Hello!');
+   * Fetch guild bans. Requires Ban Members permission.
+   * @returns List of GuildBan objects
    */
-  async fetch(channelId) {
-    const cached = this.get(channelId);
-    if (cached) return cached;
+  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 { Channel: Channel2 } = await import("./Channel-4YUSB2MM.mjs");
       const data = await this.client.rest.get(
-        Routes.channel(channelId)
+        Routes14.guildMember(this.id, userId)
       );
-      const channel = Channel2.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 && channel.guildId) {
-        const guild = this.client.guilds.get(channel.guildId);
-        if (guild) guild.channels.set(channel.id, channel);
-      }
-      return channel;
+      const member = new GuildMember(this.client, { ...data, guild_id: this.id }, this);
+      this.members.set(member.id, member);
+      return member;
     } catch (err) {
-      if (err instanceof RateLimitError) throw err;
-      if (err instanceof FluxerAPIError && err.statusCode === 404) {
-        throw new FluxerError(`Channel ${channelId} not found`, {
-          code: ErrorCodes.ChannelNotFound,
+      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(String(err), { cause: err });
+      throw err instanceof FluxerError ? err : new FluxerError("Failed to fetch guild member", { 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);
+   * Fetch guild audit logs. Requires View Audit Log permission.
+   * @param options - Optional limit, before, after, user_id, action_type for filtering
    */
-  async fetchMessage(channelId, messageId) {
-    emitDeprecationWarning(
-      "ChannelManager.fetchMessage()",
-      "Use channel.messages.fetch(messageId). Prefer (await client.channels.resolve(channelId))?.messages?.fetch(messageId)."
+  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));
+  }
+  /**
+   * 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 { Message: Message2 } = await import("./Message-R7KSI5YU.mjs");
-      const data = await this.client.rest.get(
-        Routes.channelMessage(channelId, messageId)
-      );
-      return new Message2(this.client, data);
+      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) {
-      if (err instanceof RateLimitError) throw err;
-      if (err instanceof FluxerAPIError && err.statusCode === 404) {
-        throw new FluxerError(`Message ${messageId} not found in channel ${channelId}`, {
-          code: ErrorCodes.MessageNotFound,
+      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(String(err), { cause: err });
+      throw err instanceof FluxerError ? err : new FluxerError("Failed to fetch guild emoji", { 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 }] });
+   * 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 send(channelId, payload) {
-    const opts = typeof payload === "string" ? { content: payload } : payload;
-    const body = buildSendBody(payload);
-    const { Message: Message2 } = await import("./Message-R7KSI5YU.mjs");
-    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(Routes.channelMessages(channelId), postOptions);
-    return new Message2(this.client, data);
+  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 ?? [];
+    return list.map((s) => new GuildSticker(this.client, { ...s, guild_id: this.id }, this.id));
   }
 };
 
 // src/client/GuildManager.ts
-import { Collection as Collection2 } from "@fluxerjs/collection";
-import { Routes as Routes2 } from "@fluxerjs/types";
-var GuildManager = class extends Collection2 {
+var GuildManager = class extends Collection8 {
   constructor(client) {
     super();
     this.client = client;
@@ -240,12 +2486,11 @@ var GuildManager = class extends Collection2 {
    * @returns The created guild
    */
   async create(options) {
-    const { Guild: Guild2 } = await import("./Guild-4U4U422Z.mjs");
-    const data = await this.client.rest.post(Routes2.guilds(), {
+    const data = await this.client.rest.post(Routes15.guilds(), {
       body: options,
       auth: true
     });
-    const guild = new Guild2(this.client, data);
+    const guild = new Guild(this.client, data);
     this.set(guild.id, guild);
     return guild;
   }
@@ -261,11 +2506,8 @@ var GuildManager = class extends Collection2 {
     const cached = this.get(guildId);
     if (cached) return cached;
     try {
-      const { Guild: Guild2 } = await import("./Guild-4U4U422Z.mjs");
-      const data = await this.client.rest.get(
-        Routes2.guild(guildId)
-      );
-      const guild = new Guild2(this.client, data);
+      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 {
@@ -274,18 +2516,144 @@ var GuildManager = class extends Collection2 {
   }
 };
 
+// src/structures/User.ts
+import { Routes as Routes16 } from "@fluxerjs/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 "@fluxerjs/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 emitDeprecationWarning2,
+  emitDeprecationWarning as emitDeprecationWarning3,
   formatEmoji,
   getUnicodeFromShortcode,
   parseEmoji
 } from "@fluxerjs/util";
 
 // src/client/UsersManager.ts
-import { Collection as Collection3 } from "@fluxerjs/collection";
-import { Routes as Routes3 } from "@fluxerjs/types";
-var UsersManager = class extends Collection3 {
+import { Collection as Collection9 } from "@fluxerjs/collection";
+import { Routes as Routes18 } from "@fluxerjs/types";
+var UsersManager = class extends Collection9 {
   constructor(client) {
     super();
     this.client = client;
@@ -310,7 +2678,7 @@ var UsersManager = class extends Collection3 {
    * console.log(user.username);
    */
   async fetch(userId) {
-    const data = await this.client.rest.get(Routes3.user(userId));
+    const data = await this.client.rest.get(Routes18.user(userId));
     return this.client.getOrCreateUser(data);
   }
   /**
@@ -330,10 +2698,10 @@ var UsersManager = class extends Collection3 {
   async fetchWithProfile(userId, options) {
     const guildId = options?.guildId ?? void 0;
     const [userData, globalProfileData, serverProfileData, memberData] = await Promise.all([
-      this.client.rest.get(Routes3.user(userId)),
-      this.client.rest.get(Routes3.userProfile(userId)).catch(() => null),
-      guildId ? this.client.rest.get(Routes3.userProfile(userId, guildId)).catch(() => null) : Promise.resolve(null),
-      guildId ? this.client.rest.get(Routes3.guildMember(guildId, userId)).catch(() => null) : Promise.resolve(null)
+      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;
@@ -357,25 +2725,89 @@ var UsersManager = class extends Collection3 {
   }
 };
 
+// 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 "@fluxerjs/types";
+import { FluxerAPIError as FluxerAPIError4, RateLimitError as RateLimitError3 } from "@fluxerjs/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();
 handlers.set("MESSAGE_CREATE", async (client, d) => {
-  const { Message: Message2 } = await import("./Message-R7KSI5YU.mjs");
-  const { GuildMember: GuildMember2 } = await import("./GuildMember-FSGDPKUU.mjs");
   const data = d;
   if (data.guild_id && data.member && data.author) {
     const guild = client.guilds.get(data.guild_id);
     if (guild) {
       const memberData = { ...data.member, user: data.author, guild_id: data.guild_id };
-      const member = new GuildMember2(client, memberData, guild);
+      const member = new GuildMember(client, memberData, guild);
       guild.members.set(member.id, member);
     }
   }
-  client.emit(Events.MessageCreate, new Message2(client, data));
+  client.emit(Events.MessageCreate, new Message(client, data));
 });
 handlers.set("MESSAGE_UPDATE", async (client, d) => {
-  const { Message: Message2 } = await import("./Message-R7KSI5YU.mjs");
-  client.emit(Events.MessageUpdate, null, new Message2(client, d));
+  client.emit(Events.MessageUpdate, null, new Message(client, d));
 });
 handlers.set("MESSAGE_DELETE", async (client, d) => {
   const data = d;
@@ -390,41 +2822,23 @@ handlers.set("MESSAGE_DELETE", async (client, d) => {
 });
 handlers.set("MESSAGE_REACTION_ADD", async (client, d) => {
   const data = d;
-  const { MessageReaction: MessageReaction2 } = await import("./MessageReaction-EYO7AJTL.mjs");
-  const reaction = new MessageReaction2(client, data);
+  const reaction = new MessageReaction(client, data);
   const user = client.getOrCreateUser({
     id: data.user_id,
     username: "Unknown",
     discriminator: "0"
   });
-  client.emit(
-    Events.MessageReactionAdd,
-    reaction,
-    user,
-    reaction.messageId,
-    reaction.channelId,
-    reaction.emoji,
-    user.id
-  );
+  client.emit(Events.MessageReactionAdd, reaction, user);
 });
 handlers.set("MESSAGE_REACTION_REMOVE", async (client, d) => {
   const data = d;
-  const { MessageReaction: MessageReaction2 } = await import("./MessageReaction-EYO7AJTL.mjs");
-  const reaction = new MessageReaction2(client, data);
+  const reaction = new MessageReaction(client, data);
   const user = client.getOrCreateUser({
     id: data.user_id,
     username: "Unknown",
     discriminator: "0"
   });
-  client.emit(
-    Events.MessageReactionRemove,
-    reaction,
-    user,
-    reaction.messageId,
-    reaction.channelId,
-    reaction.emoji,
-    user.id
-  );
+  client.emit(Events.MessageReactionRemove, reaction, user);
 });
 handlers.set("MESSAGE_REACTION_REMOVE_ALL", async (client, d) => {
   client.emit(Events.MessageReactionRemoveAll, d);
@@ -436,17 +2850,13 @@ handlers.set("MESSAGE_REACTION_REMOVE_EMOJI", async (client, d) => {
   );
 });
 handlers.set("GUILD_CREATE", async (client, d) => {
-  const { Guild: Guild2 } = await import("./Guild-4U4U422Z.mjs");
-  const { Channel: Channel2 } = await import("./Channel-4YUSB2MM.mjs");
-  const { GuildMember: GuildMember2 } = await import("./GuildMember-FSGDPKUU.mjs");
-  const { normalizeGuildPayload } = await import("./guildUtils-FTEGCNNJ.mjs");
   const guildData = normalizeGuildPayload(d);
   if (!guildData) return;
-  const guild = new Guild2(client, guildData);
+  const guild = new Guild(client, guildData);
   client.guilds.set(guild.id, guild);
   const g = d;
   for (const ch of g.channels ?? []) {
-    const channel = Channel2.from(client, ch);
+    const channel = Channel.from(client, ch);
     if (channel) {
       client.channels.set(channel.id, channel);
       guild.channels.set(channel.id, channel);
@@ -455,7 +2865,7 @@ handlers.set("GUILD_CREATE", async (client, d) => {
   for (const m of g.members ?? []) {
     if (m?.user?.id) {
       const memberData = { ...m, guild_id: guild.id };
-      const member = new GuildMember2(client, memberData, guild);
+      const member = new GuildMember(client, memberData, guild);
       guild.members.set(member.id, member);
     }
   }
@@ -463,14 +2873,13 @@ handlers.set("GUILD_CREATE", async (client, d) => {
   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 { Guild: Guild2 } = await import("./Guild-4U4U422Z.mjs");
-  const { normalizeGuildPayload } = await import("./guildUtils-FTEGCNNJ.mjs");
   const guildData = normalizeGuildPayload(d);
   if (!guildData) return;
   const old = client.guilds.get(guildData.id);
-  const updated = new Guild2(client, guildData);
+  const updated = new Guild(client, guildData);
   client.guilds.set(updated.id, updated);
   client.emit(Events.GuildUpdate, old ?? updated, updated);
 });
@@ -483,8 +2892,7 @@ handlers.set("GUILD_DELETE", async (client, d) => {
   }
 });
 handlers.set("CHANNEL_CREATE", async (client, d) => {
-  const { Channel: Channel2 } = await import("./Channel-4YUSB2MM.mjs");
-  const ch = Channel2.from(client, d);
+  const ch = Channel.from(client, d);
   if (ch) {
     client.channels.set(ch.id, ch);
     if ("guildId" in ch && ch.guildId) {
@@ -495,10 +2903,9 @@ handlers.set("CHANNEL_CREATE", async (client, d) => {
   }
 });
 handlers.set("CHANNEL_UPDATE", async (client, d) => {
-  const { Channel: Channel2 } = await import("./Channel-4YUSB2MM.mjs");
   const ch = d;
   const oldCh = client.channels.get(ch.id);
-  const newCh = Channel2.from(client, ch);
+  const newCh = Channel.from(client, ch);
   if (newCh) {
     client.channels.set(newCh.id, newCh);
     if ("guildId" in newCh && newCh.guildId) {
@@ -521,22 +2928,20 @@ handlers.set("CHANNEL_DELETE", async (client, d) => {
   }
 });
 handlers.set("GUILD_MEMBER_ADD", async (client, d) => {
-  const { GuildMember: GuildMember2 } = await import("./GuildMember-FSGDPKUU.mjs");
   const data = d;
   const guild = client.guilds.get(data.guild_id);
   if (guild) {
-    const member = new GuildMember2(client, data, 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 { GuildMember: GuildMember2 } = await import("./GuildMember-FSGDPKUU.mjs");
   const data = d;
   const guild = client.guilds.get(data.guild_id);
   if (guild) {
     const oldM = guild.members.get(data.user.id);
-    const newM = new GuildMember2(client, data, guild);
+    const newM = new GuildMember(client, data, guild);
     guild.members.set(newM.id, newM);
     client.emit(Events.GuildMemberUpdate, oldM ?? newM, newM);
   }
@@ -545,7 +2950,6 @@ 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;
-  const { GuildMember: GuildMember2 } = await import("./GuildMember-FSGDPKUU.mjs");
   let member = guild.members.get(data.user.id);
   if (member) {
     guild.members.delete(data.user.id);
@@ -562,7 +2966,7 @@ handlers.set("GUILD_MEMBER_REMOVE", async (client, d) => {
       joined_at: (/* @__PURE__ */ new Date(0)).toISOString(),
       nick: null
     };
-    member = new GuildMember2(client, memberData, guild);
+    member = new GuildMember(client, memberData, guild);
   }
   client.emit(Events.GuildMemberRemove, member);
 });
@@ -580,22 +2984,36 @@ handlers.set("MESSAGE_DELETE_BULK", async (client, d) => {
 });
 handlers.set("GUILD_BAN_ADD", async (client, d) => {
   const data = d;
-  const { GuildBan: GuildBan2 } = await import("./GuildBan-7CXLTPKY.mjs");
   const banData = {
     user: data.user,
     reason: data.reason ?? null,
     guild_id: data.guild_id
   };
-  const ban = new GuildBan2(client, banData, 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 { GuildBan: GuildBan2 } = await import("./GuildBan-7CXLTPKY.mjs");
-  const ban = new GuildBan2(client, { ...data, reason: null }, data.guild_id);
+  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) => {
@@ -608,8 +3026,7 @@ handlers.set("GUILD_ROLE_CREATE", async (client, d) => {
   const data = d;
   const guild = client.guilds.get(data.guild_id);
   if (guild) {
-    const { Role: Role2 } = await import("./Role-SERSJFJC.mjs");
-    guild.roles.set(data.role.id, new Role2(client, data.role, guild.id));
+    guild.roles.set(data.role.id, new Role(client, data.role, guild.id));
   }
   client.emit(Events.GuildRoleCreate, data);
 });
@@ -621,8 +3038,7 @@ handlers.set("GUILD_ROLE_UPDATE", async (client, d) => {
     if (existing) {
       existing._patch(data.role);
     } else {
-      const { Role: Role2 } = await import("./Role-SERSJFJC.mjs");
-      guild.roles.set(data.role.id, new Role2(client, data.role, guild.id));
+      guild.roles.set(data.role.id, new Role(client, data.role, guild.id));
     }
   }
   client.emit(Events.GuildRoleUpdate, data);
@@ -647,8 +3063,7 @@ handlers.set("CHANNEL_PINS_UPDATE", async (client, d) => {
 });
 handlers.set("INVITE_CREATE", async (client, d) => {
   const data = d;
-  const { Invite: Invite2 } = await import("./Invite-UM5BU5A6.mjs");
-  client.emit(Events.InviteCreate, new Invite2(client, data));
+  client.emit(Events.InviteCreate, new Invite(client, data));
 });
 handlers.set("INVITE_DELETE", async (client, d) => {
   client.emit(Events.InviteDelete, d);
@@ -686,7 +3101,7 @@ function createEventMethods(client) {
   }
   return result;
 }
-var Client = class extends EventEmitter {
+var Client = class extends EventEmitter3 {
   /** @param options - Token, REST config, WebSocket, presence, etc. */
   constructor(options = {}) {
     super();
@@ -721,6 +3136,8 @@ var Client = class extends EventEmitter {
   /** 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;
   /**
    * Resolve an emoji argument to the API format (unicode or "name:id").
    * Supports: <:name:id>, :name:, name:id, { name, id }, unicode.
@@ -751,7 +3168,7 @@ var Client = class extends EventEmitter {
     const unicodeFromShortcode = getUnicodeFromShortcode(parsed.name);
     if (unicodeFromShortcode) return unicodeFromShortcode;
     if (guildId) {
-      const emojis = await this.rest.get(Routes4.guildEmojis(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 });
@@ -772,7 +3189,7 @@ var Client = class extends EventEmitter {
    * @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(Routes4.guildEmojis(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) {
@@ -786,7 +3203,7 @@ var Client = class extends EventEmitter {
    * Does not require authentication.
    */
   async fetchInstance() {
-    return this.rest.get(Routes4.instance(), { auth: false });
+    return this.rest.get(Routes20.instance(), { auth: false });
   }
   /**
    * Fetch a message by channel and message ID. Use when you have IDs (e.g. from a DB).
@@ -800,7 +3217,7 @@ var Client = class extends EventEmitter {
    * const message = await channel?.messages?.fetch(messageId);
    */
   async fetchMessage(channelId, messageId) {
-    emitDeprecationWarning2(
+    emitDeprecationWarning3(
       "Client.fetchMessage()",
       "Use channel.messages.fetch(messageId). For IDs-only: (await client.channels.resolve(channelId))?.messages?.fetch(messageId)"
     );
@@ -810,7 +3227,8 @@ var Client = class extends EventEmitter {
    * Send a message to any channel by ID. Shorthand for client.channels.send().
    * Works even when the channel is not cached.
    */
-  async sendToChannel(channelId, payload) {
+  async sendToChannel(channelId, content) {
+    const payload = await Message._createMessageBody(content);
     return this.channels.send(channelId, payload);
   }
   /**
@@ -892,19 +3310,21 @@ var Client = class extends EventEmitter {
       async ({
         data
       }) => {
-        const { ClientUser: ClientUser2 } = await import("./ClientUser-ET7FW3XL.mjs");
-        const { Guild: Guild2 } = await import("./Guild-4U4U422Z.mjs");
-        const { Channel: Channel2 } = await import("./Channel-4YUSB2MM.mjs");
-        this.user = new ClientUser2(this, data.user);
-        const { normalizeGuildPayload } = await import("./guildUtils-FTEGCNNJ.mjs");
+        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 Guild2(this, guildData);
+          const guild = new Guild(this, guildData);
           this.guilds.set(guild.id, guild);
           const withCh = g;
           for (const ch of withCh.channels ?? []) {
-            const channel = Channel2.from(this, ch);
+            const channel = Channel.from(this, ch);
             if (channel) {
               this.channels.set(channel.id, channel);
               guild.channels.set(channel.id, channel);
@@ -917,8 +3337,11 @@ var Client = class extends EventEmitter {
             });
           }
         }
-        this.readyAt = /* @__PURE__ */ new Date();
-        this.emit(Events.Ready);
+        if (pending !== null && pending.size > 0) {
+          this._pendingGuildIds = pending;
+          return;
+        }
+        this._finalizeReady();
       }
     );
     this._ws.on("error", ({ error }) => this.emit(Events.Error, error));
@@ -926,6 +3349,25 @@ var Client = class extends EventEmitter {
     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._ws) {
@@ -935,6 +3377,7 @@ var Client = class extends EventEmitter {
     this.rest.setToken(null);
     this.user = null;
     this.readyAt = null;
+    this._pendingGuildIds = null;
     this.guilds.clear();
     this.channels.clear();
     this.users.clear();
@@ -949,24 +3392,27 @@ var Client = class extends EventEmitter {
    */
   assertReady() {
     if (!this.isReady()) {
-      throw new FluxerError("Client is not ready yet. Wait for the Ready event before accessing client.user.", {
-        code: ErrorCodes.ClientNotReady
-      });
+      throw new FluxerError(
+        "Client is not ready yet. Wait for the Ready event before accessing client.user.",
+        {
+          code: ErrorCodes.ClientNotReady
+        }
+      );
     }
   }
   static get Routes() {
-    return Routes4;
+    return Routes20;
   }
 };
 
 // src/index.ts
-import { EmbedBuilder, MessagePayload, AttachmentBuilder } from "@fluxerjs/builders";
-import { Routes as Routes5, GatewayOpcodes, MessageAttachmentFlags } from "@fluxerjs/types";
+import { EmbedBuilder as EmbedBuilder3, MessagePayload, AttachmentBuilder } from "@fluxerjs/builders";
+import { Routes as Routes21, GatewayOpcodes, MessageAttachmentFlags } from "@fluxerjs/types";
 import { resolveTenorToImageUrl, parseUserMention, parsePrefixCommand } from "@fluxerjs/util";
 import {
   PermissionsBitField,
-  PermissionFlags,
-  resolvePermissionsToBitfield,
+  PermissionFlags as PermissionFlags3,
+  resolvePermissionsToBitfield as resolvePermissionsToBitfield3,
   UserFlagsBitField,
   UserFlagsBits
 } from "@fluxerjs/util";
@@ -980,7 +3426,7 @@ export {
   Client,
   ClientUser,
   DMChannel,
-  EmbedBuilder,
+  EmbedBuilder3 as EmbedBuilder,
   ErrorCodes,
   Events,
   FluxerError,
@@ -991,6 +3437,7 @@ export {
   GuildEmoji,
   GuildMember,
   GuildMemberManager,
+  GuildMemberRoleManager,
   GuildSticker,
   Invite,
   LinkChannel,
@@ -1000,11 +3447,11 @@ export {
   MessageManager,
   MessagePayload,
   MessageReaction,
-  PermissionFlags,
+  PermissionFlags3 as PermissionFlags,
   PermissionsBitField,
   ReactionCollector,
   Role,
-  Routes5 as Routes,
+  Routes21 as Routes,
   STATIC_CDN_URL,
   TextChannel,
   User,
@@ -1021,6 +3468,6 @@ export {
   cdnMemberBannerURL,
   parsePrefixCommand,
   parseUserMention,
-  resolvePermissionsToBitfield,
+  resolvePermissionsToBitfield3 as resolvePermissionsToBitfield,
   resolveTenorToImageUrl
 };