@fluxerjs/core 1.0.8 → 1.1.0

package/dist/index.d.ts

@@ -1,14 +1,18 @@
-import { Collection } from '@fluxerjs/collection';
 import * as _fluxerjs_types from '@fluxerjs/types';
-import { APIWebhook, APIChannel, APIChannelPartial, ChannelType, APIRole, APIGuild, APIMessageAttachment, APIMessage, APIEmbed, APIUserPartial, APIGuildMember, GatewayReactionEmoji, GatewayMessageReactionAddDispatchData, GatewayMessageReactionRemoveDispatchData, GatewayPresenceUpdateData, GatewaySendPayload, Routes, GatewayMessageReactionRemoveAllDispatchData, GatewayMessageReactionRemoveEmojiDispatchData, GatewayVoiceStateUpdateDispatchData, GatewayVoiceServerUpdateDispatchData } from '@fluxerjs/types';
-export { GatewayOpcodes, Routes } from '@fluxerjs/types';
+import { APIEmbed, APIWebhook, APIWebhookUpdateRequest, APIWebhookTokenUpdateRequest, APIChannelOverwrite, APIChannel, APIChannelPartial, ChannelType, GatewayReactionEmoji, GatewayMessageReactionAddDispatchData, GatewayMessageReactionRemoveDispatchData, APIMessageAttachment, MessageType, APIMessageSticker, APIMessageReaction, APIMessageReference, APIMessageSnapshot, APIMessageCall, APIMessage, APIUserPartial, APIGuildMember, APIRole, APIBan, GuildFeature, GuildVerificationLevel, DefaultMessageNotifications, GuildExplicitContentFilter, GuildMFALevel, APIGuild, APIGuildAuditLog, APIGuildPartial, APIInvite, GatewayPresenceUpdateData, GatewayMessageReactionRemoveAllDispatchData, GatewayMessageReactionRemoveEmojiDispatchData, GatewayVoiceStateUpdateDispatchData, GatewayVoiceServerUpdateDispatchData, GatewayGuildEmojisUpdateDispatchData, GatewayGuildStickersUpdateDispatchData, GatewayGuildIntegrationsUpdateDispatchData, GatewayGuildScheduledEventCreateDispatchData, GatewayGuildScheduledEventUpdateDispatchData, GatewayGuildScheduledEventDeleteDispatchData, GatewayChannelPinsUpdateDispatchData, GatewayPresenceUpdateDispatchData, GatewayWebhooksUpdateDispatchData, GatewaySendPayload, Routes, APIEmoji, APISticker } from '@fluxerjs/types';
+export { GatewayOpcodes, MessageAttachmentFlags, Routes } from '@fluxerjs/types';
+import { Collection } from '@fluxerjs/collection';
 import { EmbedBuilder } from '@fluxerjs/builders';
 export { AttachmentBuilder, EmbedBuilder, MessagePayload } from '@fluxerjs/builders';
 import { EventEmitter } from 'events';
+import { PermissionResolvable } from '@fluxerjs/util';
+export { PermissionFlags, PermissionResolvable, PermissionString, PermissionsBitField, resolveTenorToImageUrl } from '@fluxerjs/util';
 import { REST } from '@fluxerjs/rest';
 import { WebSocketManager } from '@fluxerjs/ws';
 
+/** Base class for all Fluxer structures. Provides the client reference. */
 declare abstract class Base {
+    /** The client instance this structure belongs to. */
     abstract readonly client: Client;
 }
 
@@ -25,23 +29,102 @@ declare class MessageManager {
     /**
      * Fetch a message by ID from this channel.
      * @param messageId - Snowflake of the message
-     * @returns The message, or null if not found
+     * @returns The message
+     * @throws FluxerError with MESSAGE_NOT_FOUND if the message does not exist
      */
-    fetch(messageId: string): Promise<Message | null>;
+    fetch(messageId: string): Promise<Message>;
+}
+
+interface MessageCollectorOptions {
+    /** Filter function. Return true to collect the message. */
+    filter?: (message: Message) => boolean;
+    /** Max duration in ms. Collector stops when time expires. */
+    time?: number;
+    /** Max messages to collect. Collector stops when limit reached. */
+    max?: number;
+}
+type MessageCollectorEndReason = 'time' | 'limit' | 'user';
+interface MessageCollectorEvents {
+    collect: [message: Message];
+    end: [collected: Collection<string, Message>, reason: MessageCollectorEndReason];
+}
+/**
+ * Collects messages in a channel. Use channel.createMessageCollector().
+ * @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) => console.log(`Stopped: ${reason}`));
+ */
+declare class MessageCollector extends EventEmitter {
+    readonly client: Client;
+    readonly channelId: string;
+    readonly options: Required<MessageCollectorOptions>;
+    readonly collected: Collection<string, Message>;
+    private _timeout;
+    private _ended;
+    private _listener;
+    constructor(client: Client, channelId: string, options?: MessageCollectorOptions);
+    stop(reason?: MessageCollectorEndReason): void;
+    on<K extends keyof MessageCollectorEvents>(event: K, listener: (...args: MessageCollectorEvents[K]) => void): this;
+    emit<K extends keyof MessageCollectorEvents>(event: K, ...args: MessageCollectorEvents[K]): boolean;
 }
 
-/** Options for sending a message via webhook. */
+/** File data for message attachment uploads (Buffer supported in Node.js). */
+interface MessageFileData {
+    name: string;
+    data: Blob | ArrayBuffer | Uint8Array | Buffer;
+    filename?: string;
+}
+/** Attachment metadata for file uploads (id matches FormData index). */
+interface MessageAttachmentMeta {
+    id: number;
+    filename: string;
+    title?: string | null;
+    description?: string | null;
+    /** MessageAttachmentFlags: IS_SPOILER (8), CONTAINS_EXPLICIT_MEDIA (16), IS_ANIMATED (32) */
+    flags?: number;
+}
+/** Options for sending a message (content, embeds, files). Used by Message.send, Channel.send, ChannelManager.send. */
+type MessageSendOptions = string | {
+    content?: string;
+    embeds?: (APIEmbed | EmbedBuilder)[];
+    /** File attachments. When present, request uses multipart/form-data. */
+    files?: MessageFileData[];
+    /** Attachment metadata for files (id = index). Use when files are provided. */
+    attachments?: MessageAttachmentMeta[];
+};
+
+/** File data for webhook attachment uploads (Buffer supported in Node.js). */
+interface WebhookFileData {
+    name: string;
+    data: Blob | ArrayBuffer | Uint8Array | Buffer;
+    filename?: string;
+}
+/** Attachment metadata for webhook file uploads (id matches FormData index). */
+interface WebhookAttachmentMeta {
+    id: number;
+    filename: string;
+    title?: string | null;
+    description?: string | null;
+    /** MessageAttachmentFlags: IS_SPOILER (8), CONTAINS_EXPLICIT_MEDIA (16), IS_ANIMATED (32) */
+    flags?: number;
+}
+/** Options for sending a message via webhook. Aligns with WebhookMessageRequest in the API. */
 interface WebhookSendOptions {
-    /** Message text content */
+    /** Message text content (up to 2000 characters) */
     content?: string;
-    /** Embed objects (use EmbedBuilder.toJSON()) */
-    embeds?: Array<Record<string, unknown>>;
-    /** Override the webhook's default username */
+    /** Embed objects. Use EmbedBuilder or APIEmbed; EmbedBuilder is serialized automatically. */
+    embeds?: (APIEmbed | EmbedBuilder)[];
+    /** Override the webhook's default username for this message */
     username?: string;
-    /** Override the webhook's default avatar URL */
+    /** Override the webhook's default avatar URL for this message */
     avatar_url?: string;
     /** Text-to-speech */
     tts?: boolean;
+    /** File attachments. When present, uses multipart/form-data (same as channel.send). */
+    files?: WebhookFileData[];
+    /** Attachment metadata for files (id = index). Use when files are provided. */
+    attachments?: WebhookAttachmentMeta[];
 }
 /**
  * Represents a Discord/Fluxer webhook. Supports creating, fetching, sending, and deleting.
@@ -51,22 +134,45 @@ declare class Webhook extends Base {
     readonly client: Client;
     readonly id: string;
     readonly guildId: string;
-    readonly channelId: string;
+    channelId: string;
     name: string;
     avatar: string | null;
     /** Present only when webhook was created via createWebhook(); not returned when fetching. */
     readonly token: string | null;
+    /** User who created the webhook. */
+    readonly user: User;
     /** @param data - API webhook from POST /channels/{id}/webhooks (has token) or GET /webhooks/{id} (no token) */
     constructor(client: Client, data: APIWebhook & {
         token?: string | null;
     });
+    /**
+     * Get the URL for this webhook's avatar.
+     * Returns null if the webhook has no custom avatar.
+     */
+    avatarURL(options?: {
+        size?: number;
+        extension?: string;
+    }): string | null;
     /** Delete this webhook. Requires bot token with Manage Webhooks permission. */
     delete(): Promise<void>;
+    /**
+     * 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
+     */
+    edit(options: APIWebhookUpdateRequest | APIWebhookTokenUpdateRequest): Promise<Webhook>;
     /**
      * Send a message via this webhook. Requires the webhook token (only present when created, not when fetched).
+     * @param options - Text content or object with content, embeds, username, avatar_url, tts, files, attachments
+     * @param wait - If true, waits for the API and returns the created Message; otherwise returns void (204)
      * @throws Error if token is not available
+     * @example
+     * await webhook.send('Hello!');
+     * await webhook.send({ embeds: [embed.toJSON()] });
+     * await webhook.send({ content: 'File attached', files: [{ name: 'data.txt', data: buffer }] });
+     * const msg = await webhook.send({ content: 'Hi' }, true);
      */
-    send(options: string | WebhookSendOptions): Promise<void>;
+    send(options: string | WebhookSendOptions, wait?: boolean): Promise<Message | undefined>;
     /**
      * Fetch a webhook by ID using bot auth.
      * @param client - The client instance
@@ -101,6 +207,12 @@ declare abstract class Channel extends Base {
     readonly client: Client;
     readonly id: string;
     type: ChannelType;
+    /** Channel name. Guild channels and Group DMs have names; 1:1 DMs are typically null. */
+    name: string | null;
+    /** Channel icon hash (Group DMs). Null if none. */
+    icon: string | null;
+    /** ISO timestamp when the last message was pinned. Null if never pinned. */
+    lastPinTimestamp: string | null;
     /** @param data - API channel from GET /channels/{id} or GET /guilds/{id}/channels */
     constructor(client: Client, data: APIChannelPartial);
     /**
@@ -114,12 +226,23 @@ declare abstract class Channel extends Base {
      * Used by ChannelManager.fetch() for GET /channels/{id}.
      */
     static fromOrCreate(client: Client, data: APIChannel | APIChannelPartial): TextChannel | DMChannel | GuildChannel | null;
+    /**
+     * Bulk delete messages. Requires Manage Messages permission.
+     * @param messageIds - Array of message IDs to delete (2–100)
+     */
+    bulkDeleteMessages(messageIds: string[]): Promise<void>;
+    /**
+     * Send a typing indicator to the channel. Lasts ~10 seconds.
+     */
+    sendTyping(): Promise<void>;
 }
 declare class GuildChannel extends Channel {
     readonly guildId: string;
     name: string | null;
     position?: number;
     parentId: string | null;
+    /** Permission overwrites for roles and members. */
+    permissionOverwrites: APIChannelOverwrite[];
     constructor(client: Client, data: APIChannel);
     /**
      * Create a webhook in this channel.
@@ -135,6 +258,22 @@ declare class GuildChannel extends Channel {
      * @returns Webhooks (includes token when listing from channel; can send via send())
      */
     fetchWebhooks(): Promise<Webhook[]>;
+    /**
+     * Create an invite for this channel.
+     * @param options - max_uses (0–100), max_age (0–604800 seconds), unique, temporary
+     * Requires Create Instant Invite permission.
+     */
+    createInvite(options?: {
+        max_uses?: number;
+        max_age?: number;
+        unique?: boolean;
+        temporary?: boolean;
+    }): Promise<Invite>;
+    /**
+     * Fetch invites for this channel.
+     * Requires Manage Channel permission.
+     */
+    fetchInvites(): Promise<Invite[]>;
 }
 declare class TextChannel extends GuildChannel {
     topic?: string | null;
@@ -144,21 +283,33 @@ declare class TextChannel extends GuildChannel {
     constructor(client: Client, data: APIChannel);
     /**
      * Send a message to this channel.
-     * @param options - Text content or object with `content` and/or `embeds`
+     * @param options - Text content or object with content, embeds, and/or files
      */
-    send(options: string | {
-        content?: string;
-        embeds?: unknown[];
-    }): Promise<Message>;
+    send(options: MessageSendOptions): Promise<Message>;
     /** Message manager for this channel. Use channel.messages.fetch(messageId). */
     get messages(): MessageManager;
+    /**
+     * 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?: MessageCollectorOptions): MessageCollector;
+    /**
+     * Fetch pinned messages in this channel.
+     * @returns Pinned messages
+     */
+    fetchPinnedMessages(): Promise<Message[]>;
     /**
      * 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.
      */
-    fetchMessage(messageId: string): Promise<Message | null>;
+    fetchMessage(messageId: string): Promise<Message>;
 }
 declare class CategoryChannel extends GuildChannel {
 }
@@ -175,98 +326,98 @@ declare class LinkChannel extends GuildChannel {
 /** DM channel (direct message between bot and a user). */
 declare class DMChannel extends Channel {
     lastMessageId?: string | null;
-    constructor(client: Client, data: APIChannelPartial);
+    /** Group DM creator ID. Null for 1:1 DMs. */
+    ownerId: string | null;
+    /** Group DM recipients as User objects. Empty for 1:1 DMs. */
+    recipients: User[];
+    /** Group DM member display names (userId -> nickname). */
+    nicks: Record<string, string>;
+    constructor(client: Client, data: APIChannelPartial & Partial<APIChannel>);
     /**
      * Send a message to this DM channel.
-     * @param options - Text content or object with `content` and/or `embeds`
+     * @param options - Text content or object with content, embeds, and/or files
      */
-    send(options: string | {
-        content?: string;
-        embeds?: unknown[];
-    }): Promise<Message>;
+    send(options: MessageSendOptions): Promise<Message>;
     /** Message manager for this channel. Use channel.messages.fetch(messageId). */
     get messages(): MessageManager;
+    /**
+     * Create a message collector for this DM channel.
+     * @param options - Filter, time (ms), and max count
+     */
+    createMessageCollector(options?: MessageCollectorOptions): MessageCollector;
+    /**
+     * Fetch pinned messages in this DM channel.
+     * @returns Pinned messages
+     */
+    fetchPinnedMessages(): Promise<Message[]>;
     /**
      * 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.
      */
-    fetchMessage(messageId: string): Promise<Message | null>;
+    fetchMessage(messageId: string): Promise<Message>;
 }
 
-/** Represents a role in a guild. */
-declare class Role extends Base {
+/** Represents a reaction added to or removed from a message. */
+declare class MessageReaction extends Base {
     readonly client: Client;
-    readonly id: string;
-    readonly guildId: string;
-    name: string;
-    color: number;
-    position: number;
-    permissions: string;
-    hoist: boolean;
-    mentionable: boolean;
-    unicodeEmoji: string | null;
-    /** @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: Client, data: APIRole, guildId: string);
-    /** Returns a mention string (e.g. `<@&123456>`). */
-    toString(): string;
+    readonly messageId: string;
+    readonly channelId: string;
+    readonly guildId: string | null;
+    readonly emoji: GatewayReactionEmoji;
+    /** Raw gateway payload for low-level access. */
+    readonly _data: GatewayMessageReactionAddDispatchData | GatewayMessageReactionRemoveDispatchData;
+    constructor(client: Client, data: GatewayMessageReactionAddDispatchData | GatewayMessageReactionRemoveDispatchData);
+    /** Emoji as a string: unicode or "name:id" for custom. */
+    get emojiIdentifier(): string;
+    /** Guild where this reaction was added. Resolved from cache; null for DMs or if not cached. */
+    get guild(): Guild | 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
+     */
+    fetchMessage(): Promise<Message>;
 }
 
-/** Represents a Fluxer guild (server). */
-declare class Guild extends Base {
+interface ReactionCollectorOptions {
+    /** Filter function. Return true to collect the reaction. */
+    filter?: (reaction: MessageReaction, user: User) => boolean;
+    /** Max duration in ms. Collector stops when time expires. */
+    time?: number;
+    /** Max reactions to collect. Collector stops when limit reached. */
+    max?: number;
+}
+type ReactionCollectorEndReason = 'time' | 'limit' | 'user';
+interface CollectedReaction {
+    reaction: MessageReaction;
+    user: User;
+}
+interface ReactionCollectorEvents {
+    collect: [reaction: MessageReaction, user: User];
+    end: [collected: Collection<string, CollectedReaction>, reason: ReactionCollectorEndReason];
+}
+/**
+ * Collects reactions on a message. Use message.createReactionCollector().
+ * @example
+ * const collector = message.createReactionCollector({ filter: (r, u) => u.id === userId, time: 10000 });
+ * collector.on('collect', (reaction, user) => console.log(user.username, 'reacted', reaction.emoji.name));
+ * collector.on('end', (collected, reason) => console.log(`Stopped: ${reason}`));
+ */
+declare class ReactionCollector extends EventEmitter {
     readonly client: Client;
-    readonly id: string;
-    name: string;
-    icon: string | null;
-    banner: string | null;
-    readonly ownerId: string;
-    members: Collection<string, GuildMember>;
-    channels: Collection<string, GuildChannel>;
-    roles: Collection<string, Role>;
-    /** @param data - API guild from GET /guilds/{id} or gateway GUILD_CREATE */
-    constructor(client: Client, data: APIGuild & {
-        roles?: APIRole[];
-    });
-    /** Get the guild icon URL, or null if no icon. */
-    iconURL(options?: {
-        size?: number;
-    }): string | null;
-    /** Get the guild banner URL, or null if no banner. */
-    bannerURL(options?: {
-        size?: number;
-    }): string | null;
-    /**
-     * 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.
-     */
-    addRoleToMember(userId: string, roleId: string): Promise<void>;
-    /**
-     * 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.
-     */
-    removeRoleFromMember(userId: string, roleId: string): Promise<void>;
-    /**
-     * 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
-     */
-    resolveRoleId(arg: string): Promise<string | null>;
-    /**
-     * Fetch a guild member by user ID.
-     * @param userId - The user ID of the member to fetch
-     * @returns The guild member, or null if not found
-     */
-    fetchMember(userId: string): Promise<GuildMember | null>;
-    /** Fetch all webhooks in this guild. Returned webhooks do not include the token (cannot send). */
-    fetchWebhooks(): Promise<Webhook[]>;
+    readonly messageId: string;
+    readonly channelId: string;
+    readonly options: Required<ReactionCollectorOptions>;
+    readonly collected: Collection<string, CollectedReaction>;
+    private _timeout;
+    private _ended;
+    private _listener;
+    constructor(client: Client, messageId: string, channelId: string, options?: ReactionCollectorOptions);
+    stop(reason?: ReactionCollectorEndReason): void;
+    on<K extends keyof ReactionCollectorEvents>(event: K, listener: (...args: ReactionCollectorEvents[K]) => void): this;
+    emit<K extends keyof ReactionCollectorEvents>(event: K, ...args: ReactionCollectorEvents[K]): boolean;
 }
 
 /** Options for editing a message (content and/or embeds). */
@@ -276,6 +427,7 @@ interface MessageEditOptions {
     /** New embeds (replaces existing) */
     embeds?: (APIEmbed | EmbedBuilder)[];
 }
+
 /** Represents a message in a channel. */
 declare class Message extends Base {
     readonly client: Client;
@@ -288,6 +440,25 @@ declare class Message extends Base {
     readonly editedAt: Date | null;
     pinned: boolean;
     readonly attachments: Collection<string, APIMessageAttachment>;
+    readonly type: MessageType;
+    readonly flags: number;
+    readonly mentionEveryone: boolean;
+    readonly tts: boolean;
+    readonly embeds: APIEmbed[];
+    readonly stickers: APIMessageSticker[];
+    readonly reactions: APIMessageReaction[];
+    readonly messageReference: APIMessageReference | null;
+    readonly messageSnapshots: APIMessageSnapshot[];
+    readonly call: APIMessageCall | null;
+    readonly referencedMessage: Message | null;
+    /** Webhook ID if this message was sent via webhook. Null otherwise. */
+    readonly webhookId: string | null;
+    /** Users mentioned in this message. */
+    readonly mentions: User[];
+    /** Role IDs mentioned in this message. */
+    readonly mentionRoles: string[];
+    /** Client-side nonce for acknowledgment. Null if not provided. */
+    readonly nonce: string | null;
     /** Channel where this message was sent. Resolved from cache; null if not cached (e.g. DM channel not in cache). */
     get channel(): Channel | null;
     /** Guild where this message was sent. Resolved from cache; null for DMs or if not cached. */
@@ -296,15 +467,13 @@ declare class Message extends Base {
     constructor(client: Client, data: APIMessage);
     /**
      * Send a message to this channel without replying. Use when you want a standalone message.
-     * @param options - Text content or object with content and/or embeds
+     * @param options - Text content or object with content, embeds, and/or files
      * @example
      * await message.send('Pong!');
      * await message.send({ embeds: [embed.toJSON()] });
+     * await message.send({ content: 'File', files: [{ name: 'data.txt', data }] });
      */
-    send(options: string | {
-        content?: string;
-        embeds?: APIEmbed[];
-    }): Promise<Message>;
+    send(options: MessageSendOptions): Promise<Message>;
     /**
      * 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)
@@ -313,34 +482,43 @@ declare class Message extends Base {
      * await message.sendTo(logChannelId, 'User ' + message.author.username + ' said: ' + message.content);
      * await message.sendTo(announceChannelId, { embeds: [embed.toJSON()] });
      */
-    sendTo(channelId: string, options: string | {
-        content?: string;
-        embeds?: APIEmbed[];
-    }): Promise<Message>;
+    sendTo(channelId: string, options: MessageSendOptions): Promise<Message>;
     /**
      * Reply to this message.
-     * @param options - Text content or object with content and/or embeds
+     * @param options - Text content or object with content, embeds, and/or files
      */
-    reply(options: string | {
-        content?: string;
-        embeds?: APIEmbed[];
-    }): Promise<Message>;
+    reply(options: MessageSendOptions): Promise<Message>;
     /**
      * Edit this message. Only the author (or admins) can edit.
      * @param options - New content and/or embeds
      */
     edit(options: MessageEditOptions): Promise<Message>;
+    /**
+     * 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?: ReactionCollectorOptions): ReactionCollector;
     /**
      * Re-fetch this message from the API to get the latest content, embeds, reactions, etc.
      * Use when you have a stale Message (e.g. from an old event or cache) and need fresh data.
-     * @returns The updated message, or null if deleted or not found
+     * @returns The updated message
+     * @throws FluxerError with MESSAGE_NOT_FOUND if the message was deleted or does not exist
      * @example
      * const updated = await message.fetch();
-     * if (updated) console.log('Latest content:', updated.content);
+     * console.log('Latest content:', updated.content);
      */
-    fetch(): Promise<Message | null>;
+    fetch(): Promise<Message>;
     /** Delete this message. */
     delete(): Promise<void>;
+    /** Pin this message to the channel. Requires Manage Messages permission. */
+    pin(): Promise<void>;
+    /** Unpin this message from the channel. Requires Manage Messages permission. */
+    unpin(): Promise<void>;
     /**
      * 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.
@@ -380,6 +558,20 @@ declare class Message extends Base {
         id?: string;
         animated?: boolean;
     }): Promise<void>;
+    /**
+     * 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
+     */
+    fetchReactionUsers(emoji: string | {
+        name: string;
+        id?: string;
+        animated?: boolean;
+    }, options?: {
+        limit?: number;
+        after?: string;
+    }): Promise<User[]>;
 }
 
 /** Represents a user (or bot) on Fluxer. */
@@ -391,13 +583,22 @@ declare class User extends Base {
     globalName: string | null;
     avatar: string | null;
     readonly bot: boolean;
+    /** RGB avatar color (e.g. 7577782). Null if not set. */
+    avatarColor: number | null;
+    /** Public flags bitfield. Null if not set. */
+    flags: number | null;
+    /** Whether this is an official system user. */
+    readonly system: boolean;
+    /** Banner hash (from profile, member, or invite context). Null when not available. */
+    banner: string | null;
     /** @param data - API user from message author, GET /users/{id}, or GET /users/@me */
     constructor(client: Client, data: APIUserPartial);
     /** Update mutable fields from fresh API data. Used by getOrCreateUser cache. */
     _patch(data: APIUserPartial): void;
     /**
      * Get the URL for this user's avatar.
-     * @param options - Optional `size` and `extension` (default: `png`)
+     * Auto-detects animated avatars (hash starting with `a_`) and uses gif extension.
+     * @param options - Optional `size` and `extension` (default: png, or gif for animated)
      */
     avatarURL(options?: {
         size?: number;
@@ -406,7 +607,16 @@ declare class User extends Base {
     /** Get the avatar URL, or the default avatar if none set. */
     displayAvatarURL(options?: {
         size?: number;
+        extension?: string;
     }): string;
+    /**
+     * 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?: {
+        size?: number;
+        extension?: string;
+    }): string | null;
     /** Returns a mention string (e.g. `<@123456>`). */
     toString(): string;
     /**
@@ -418,10 +628,7 @@ declare class User extends Base {
      * Send a DM to this user.
      * Convenience method that creates the DM channel and sends the message.
      */
-    send(options: string | {
-        content?: string;
-        embeds?: unknown[];
-    }): Promise<Message>;
+    send(options: MessageSendOptions): Promise<Message>;
 }
 
 /** Represents a member of a guild. */
@@ -434,12 +641,42 @@ declare class GuildMember extends Base {
     readonly roles: string[];
     readonly joinedAt: Date;
     communicationDisabledUntil: Date | null;
+    readonly mute: boolean;
+    readonly deaf: boolean;
+    readonly avatar: string | null;
+    readonly banner: string | null;
+    readonly accentColor: number | null;
+    readonly profileFlags: number | null;
     /** @param data - API guild member from GET /guilds/{id}/members or GET /guilds/{id}/members/{user_id} */
     constructor(client: Client, data: APIGuildMember & {
         guild_id?: string;
     }, guild: Guild);
     /** Nickname, or global name, or username. */
     get displayName(): string;
+    /**
+     * Get the guild-specific avatar URL for this member.
+     * Returns null if the member has no guild avatar (use displayAvatarURL for fallback).
+     */
+    avatarURL(options?: {
+        size?: number;
+        extension?: string;
+    }): string | null;
+    /**
+     * 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?: {
+        size?: number;
+        extension?: string;
+    }): string;
+    /**
+     * Get the guild-specific banner URL for this member.
+     * Returns null if the member has no guild banner.
+     */
+    bannerURL(options?: {
+        size?: number;
+        extension?: string;
+    }): string | null;
     /**
      * Add a role to this member.
      * @param roleId - The role ID to add
@@ -452,27 +689,276 @@ declare class GuildMember extends Base {
      * Requires Manage Roles permission.
      */
     removeRole(roleId: string): Promise<void>;
+    /**
+     * 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(): {
+        has(permission: PermissionResolvable): boolean;
+    };
+    /**
+     * 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: GuildChannel): {
+        has(permission: PermissionResolvable): boolean;
+    };
+    private _computeBasePermissions;
 }
 
-/** Represents a reaction added to or removed from a message. */
-declare class MessageReaction extends Base {
+/** Represents a role in a guild. */
+declare class Role extends Base {
     readonly client: Client;
-    readonly messageId: string;
-    readonly channelId: string;
-    readonly guildId: string | null;
-    readonly emoji: GatewayReactionEmoji;
-    /** Raw gateway payload for low-level access. */
-    readonly _data: GatewayMessageReactionAddDispatchData | GatewayMessageReactionRemoveDispatchData;
-    constructor(client: Client, data: GatewayMessageReactionAddDispatchData | GatewayMessageReactionRemoveDispatchData);
-    /** Emoji as a string: unicode or "name:id" for custom. */
-    get emojiIdentifier(): string;
-    /** Guild where this reaction was added. Resolved from cache; null for DMs or if not cached. */
-    get guild(): Guild | null;
+    readonly id: string;
+    readonly guildId: string;
+    name: string;
+    color: number;
+    position: number;
+    permissions: string;
+    hoist: boolean;
+    mentionable: boolean;
+    unicodeEmoji: string | null;
+    /** Separately sorted position for hoisted roles. Null if not set. */
+    hoistPosition: number | null;
+    /** @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: Client, data: APIRole, guildId: string);
+    /** Returns a mention string (e.g. `<@&123456>`). */
+    toString(): string;
     /**
-     * Fetch the message this reaction belongs to.
-     * Use when you need to edit, delete, or otherwise interact with the message.
+     * 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: PermissionResolvable): boolean;
+}
+
+/** Represents a ban in a guild. */
+declare class GuildBan extends Base {
+    readonly client: Client;
+    readonly guildId: string;
+    readonly user: User;
+    readonly reason: string | null;
+    /** ISO timestamp when a temporary ban expires. Null for permanent bans. */
+    readonly expiresAt: string | null;
+    /** @param data - API ban from GET /guilds/{id}/bans or gateway GUILD_BAN_ADD */
+    constructor(client: Client, data: APIBan & {
+        guild_id?: string;
+    }, guildId: string);
+    /**
+     * Remove this ban (unban the user).
+     * Requires Ban Members permission.
+     */
+    unban(): Promise<void>;
+}
+
+/** Represents a Fluxer guild (server). */
+declare class Guild extends Base {
+    readonly client: Client;
+    readonly id: string;
+    name: string;
+    icon: string | null;
+    banner: string | null;
+    readonly ownerId: string;
+    /** Invite splash image hash. Null if none. */
+    splash: string | null;
+    /** Custom vanity URL code (e.g. fluxer.gg/code). Null if none. */
+    vanityURLCode: string | null;
+    /** Enabled guild features. */
+    features: GuildFeature[];
+    verificationLevel: GuildVerificationLevel;
+    defaultMessageNotifications: DefaultMessageNotifications;
+    explicitContentFilter: GuildExplicitContentFilter;
+    /** AFK voice channel ID. Null if none. */
+    afkChannelId: string | null;
+    /** AFK timeout in seconds. */
+    afkTimeout: number;
+    /** System messages channel ID. Null if none. */
+    systemChannelId: string | null;
+    /** Rules/guidelines channel ID. Null if none. */
+    rulesChannelId: string | null;
+    nsfwLevel: number;
+    mfaLevel: GuildMFALevel;
+    /** Banner image width. Optional. */
+    bannerWidth?: number | null;
+    /** Banner image height. Optional. */
+    bannerHeight?: number | null;
+    /** Splash image width. Optional. */
+    splashWidth?: number | null;
+    /** Splash image height. Optional. */
+    splashHeight?: number | null;
+    members: Collection<string, GuildMember>;
+    channels: Collection<string, GuildChannel>;
+    roles: Collection<string, Role>;
+    /** @param data - API guild from GET /guilds/{id} or gateway GUILD_CREATE */
+    constructor(client: Client, data: APIGuild & {
+        roles?: APIRole[];
+        ownerId?: string;
+    });
+    /** Get the guild icon URL, or null if no icon. */
+    iconURL(options?: {
+        size?: number;
+    }): string | null;
+    /** Get the guild banner URL, or null if no banner. */
+    bannerURL(options?: {
+        size?: number;
+    }): string | null;
+    /** Get the guild splash (invite background) URL, or null if no splash. */
+    splashURL(options?: {
+        size?: number;
+    }): string | null;
+    /**
+     * 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.
+     */
+    addRoleToMember(userId: string, roleId: string): Promise<void>;
+    /**
+     * 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.
+     */
+    removeRoleFromMember(userId: string, roleId: string): Promise<void>;
+    /**
+     * 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
+     */
+    resolveRoleId(arg: string): Promise<string | null>;
+    /**
+     * Ban a user from this guild.
+     * @param userId - The user ID to ban
+     * @param options - Optional reason, delete_message_days (0–7), and ban_duration_seconds (temporary ban).
+     *   ban_duration_seconds: 0 = permanent, or use 3600, 43200, 86400, 259200, 432000, 604800, 1209600, 2592000.
+     * Requires Ban Members permission.
+     */
+    ban(userId: string, options?: {
+        reason?: string;
+        delete_message_days?: number;
+        ban_duration_seconds?: number;
+    }): Promise<void>;
+    /**
+     * Fetch guild bans. Requires Ban Members permission.
+     * @returns List of GuildBan objects
+     */
+    fetchBans(): Promise<GuildBan[]>;
+    /**
+     * Remove a ban (unban a user).
+     * @param userId - The user ID to unban
+     * Requires Ban Members permission.
+     */
+    unban(userId: string): Promise<void>;
+    /**
+     * Kick a member from this guild.
+     * @param userId - The user ID to kick
+     * Requires Kick Members permission.
+     */
+    kick(userId: string): Promise<void>;
+    /**
+     * 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
+     */
+    fetchMember(userId: string): Promise<GuildMember>;
+    /**
+     * Fetch guild audit logs. Requires View Audit Log permission.
+     * @param options - Optional limit, before, after, user_id, action_type for filtering
      */
-    fetchMessage(): Promise<Message | null>;
+    fetchAuditLogs(options?: {
+        limit?: number;
+        before?: string;
+        after?: string;
+        userId?: string;
+        actionType?: number;
+    }): Promise<APIGuildAuditLog>;
+    /** Fetch all webhooks in this guild. Returned webhooks do not include the token (cannot send). */
+    fetchWebhooks(): Promise<Webhook[]>;
+    /**
+     * 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.
+     */
+    createChannel(data: {
+        type: 0 | 2 | 4 | 5;
+        name: string;
+        parent_id?: string | null;
+        topic?: string | null;
+        bitrate?: number | null;
+        user_limit?: number | null;
+        nsfw?: boolean;
+        permission_overwrites?: Array<{
+            id: string;
+            type: number;
+            allow: string;
+            deny: string;
+        }>;
+    }): Promise<GuildChannel>;
+    /**
+     * Fetch all channels in this guild.
+     * @returns Array of GuildChannel objects (cached in guild.channels and client.channels)
+     */
+    fetchChannels(): Promise<GuildChannel[]>;
+    /**
+     * Update channel positions.
+     * @param updates - Array of { id, position?, parent_id?, lock_permissions? }
+     * Requires Manage Channels permission.
+     */
+    setChannelPositions(updates: Array<{
+        id: string;
+        position?: number;
+        parent_id?: string | null;
+        lock_permissions?: boolean;
+    }>): Promise<void>;
+}
+
+/** Represents an invite to a guild or channel. */
+declare class Invite extends Base {
+    readonly client: Client;
+    readonly code: string;
+    readonly type: number;
+    readonly guild: APIGuildPartial;
+    readonly channel: APIChannelPartial;
+    readonly inviter: User | null;
+    readonly memberCount: number | null;
+    readonly presenceCount: number | null;
+    readonly expiresAt: string | null;
+    readonly temporary: boolean | null;
+    readonly createdAt: string | null;
+    readonly uses: number | null;
+    readonly maxUses: number | null;
+    readonly maxAge: number | null;
+    /** @param data - API invite from GET /invites/{code}, channel/guild invite list, or gateway INVITE_CREATE */
+    constructor(client: Client, data: APIInvite);
+    /** Full invite URL (https://fluxer.gg/{code} or instance-specific). */
+    get url(): string;
+    /**
+     * Resolve the guild from cache if available.
+     * @returns The guild, or null if not cached
+     */
+    getGuild(): Guild | null;
+    /**
+     * Delete this invite.
+     * Requires Manage Guild or Create Instant Invite permission.
+     */
+    delete(): Promise<void>;
 }
 
 /** Minimal message data for MessageDelete when the full message is not available. */
@@ -492,37 +978,37 @@ declare class ChannelManager extends Collection<string, Channel> {
     /**
      * Fetch a channel by ID from the API (or return from cache if present).
      * @param channelId - Snowflake of the channel
-     * @returns The channel, or null if not found
+     * @returns The channel
+     * @throws FluxerError with CHANNEL_NOT_FOUND if the channel does not exist
      * @example
      * const channel = await client.channels.fetch(channelId);
      * if (channel?.isSendable()) await channel.send('Hello!');
      */
-    fetch(channelId: string): Promise<Channel | null>;
+    fetch(channelId: string): Promise<Channel>;
     /**
      * Fetch a message by ID from the API.
      * @param channelId - Snowflake of the channel
      * @param messageId - Snowflake of the message
-     * @returns The message, or null if not found
+     * @returns The message
+     * @throws FluxerError with MESSAGE_NOT_FOUND if the message does not exist
      * @deprecated Use channel.messages.fetch(messageId). Prefer (await client.channels.fetch(channelId))?.messages?.fetch(messageId).
      * @example
      * const channel = await client.channels.fetch(channelId);
      * const message = await channel?.messages?.fetch(messageId);
      */
-    fetchMessage(channelId: string, messageId: string): Promise<Message | null>;
+    fetchMessage(channelId: string, messageId: string): Promise<Message>;
     /**
      * Send a message to a channel by ID. Works even when the channel is not cached.
      * Skips the fetch when you only need to send.
      * @param channelId - Snowflake of the channel (text channel or DM)
-     * @param payload - Text content or object with content and/or embeds
+     * @param payload - Text content or object with content, embeds, and/or files
      * @returns The created message
      * @example
      * await client.channels.send(logChannelId, 'User joined!');
      * await client.channels.send(channelId, { embeds: [embed.toJSON()] });
+     * await client.channels.send(channelId, { content: 'Report', files: [{ name: 'log.txt', data }] });
      */
-    send(channelId: string, payload: string | {
-        content?: string;
-        embeds?: _fluxerjs_types.APIEmbed[];
-    }): Promise<Message>;
+    send(channelId: string, payload: MessageSendOptions): Promise<Message>;
 }
 
 /**
@@ -561,8 +1047,19 @@ interface ClientOptions {
 declare class ClientUser extends User {
     readonly client: Client;
     constructor(client: Client, data: APIUserPartial);
+    /**
+     * Fetch guilds the bot is a member of.
+     * @returns Array of Guild objects (cached in client.guilds)
+     */
+    fetchGuilds(): Promise<Guild[]>;
+    /**
+     * Leave a guild. Requires the bot to be a member.
+     * @param guildId - The guild ID to leave
+     */
+    leaveGuild(guildId: string): Promise<void>;
 }
 
+/** Event name constants for client.on(Events.X, handler). Use with ClientEvents for typed callbacks. */
 declare const Events: {
     readonly Ready: "ready";
     readonly MessageCreate: "messageCreate";
@@ -609,6 +1106,10 @@ declare const Events: {
     readonly Debug: "debug";
 };
 
+/**
+ * Callback parameter types for client events. Use with client.on(Events.X, handler).
+ * @see Events
+ */
 interface ClientEvents {
     [Events.Ready]: [];
     [Events.MessageCreate]: [message: Message];
@@ -619,11 +1120,19 @@ interface ClientEvents {
     [Events.MessageDelete]: [message: PartialMessage];
     [Events.MessageReactionAdd]: [
         reaction: MessageReaction,
-        user: User
+        user: User,
+        messageId: string,
+        channelId: string,
+        emoji: GatewayReactionEmoji,
+        userId: string
     ];
     [Events.MessageReactionRemove]: [
         reaction: MessageReaction,
-        user: User
+        user: User,
+        messageId: string,
+        channelId: string,
+        emoji: GatewayReactionEmoji,
+        userId: string
     ];
     [Events.MessageReactionRemoveAll]: [data: GatewayMessageReactionRemoveAllDispatchData];
     [Events.MessageReactionRemoveEmoji]: [data: GatewayMessageReactionRemoveEmojiDispatchData];
@@ -656,28 +1165,32 @@ interface ClientEvents {
     [Events.MessageDeleteBulk]: [
         data: _fluxerjs_types.GatewayMessageDeleteBulkDispatchData
     ];
-    [Events.GuildBanAdd]: [data: _fluxerjs_types.GatewayGuildBanAddDispatchData];
-    [Events.GuildBanRemove]: [data: _fluxerjs_types.GatewayGuildBanRemoveDispatchData];
-    [Events.GuildEmojisUpdate]: [data: unknown];
-    [Events.GuildStickersUpdate]: [data: unknown];
-    [Events.GuildIntegrationsUpdate]: [data: unknown];
+    [Events.GuildBanAdd]: [ban: GuildBan];
+    [Events.GuildBanRemove]: [ban: GuildBan];
+    [Events.GuildEmojisUpdate]: [data: GatewayGuildEmojisUpdateDispatchData];
+    [Events.GuildStickersUpdate]: [data: GatewayGuildStickersUpdateDispatchData];
+    [Events.GuildIntegrationsUpdate]: [data: GatewayGuildIntegrationsUpdateDispatchData];
     [Events.GuildRoleCreate]: [data: _fluxerjs_types.GatewayGuildRoleCreateDispatchData];
     [Events.GuildRoleUpdate]: [data: _fluxerjs_types.GatewayGuildRoleUpdateDispatchData];
     [Events.GuildRoleDelete]: [data: _fluxerjs_types.GatewayGuildRoleDeleteDispatchData];
-    [Events.GuildScheduledEventCreate]: [data: unknown];
-    [Events.GuildScheduledEventUpdate]: [data: unknown];
-    [Events.GuildScheduledEventDelete]: [data: unknown];
-    [Events.ChannelPinsUpdate]: [data: unknown];
-    [Events.InviteCreate]: [data: unknown];
-    [Events.InviteDelete]: [data: unknown];
+    [Events.GuildScheduledEventCreate]: [data: GatewayGuildScheduledEventCreateDispatchData];
+    [Events.GuildScheduledEventUpdate]: [data: GatewayGuildScheduledEventUpdateDispatchData];
+    [Events.GuildScheduledEventDelete]: [data: GatewayGuildScheduledEventDeleteDispatchData];
+    [Events.ChannelPinsUpdate]: [data: GatewayChannelPinsUpdateDispatchData];
+    [Events.InviteCreate]: [invite: Invite];
+    [Events.InviteDelete]: [data: _fluxerjs_types.GatewayInviteDeleteDispatchData];
     [Events.TypingStart]: [data: _fluxerjs_types.GatewayTypingStartDispatchData];
     [Events.UserUpdate]: [data: _fluxerjs_types.GatewayUserUpdateDispatchData];
-    [Events.PresenceUpdate]: [data: unknown];
-    [Events.WebhooksUpdate]: [data: unknown];
+    [Events.PresenceUpdate]: [data: GatewayPresenceUpdateDispatchData];
+    [Events.WebhooksUpdate]: [data: GatewayWebhooksUpdateDispatchData];
     [Events.Resumed]: [];
     [Events.Error]: [error: Error];
     [Events.Debug]: [message: string];
 }
+/** Typed event handler methods. Use client.events.MessageReactionAdd((reaction, user, messageId, channelId, emoji, userId) => {...}) or client.on(Events.MessageReactionAdd, ...). */
+type ClientEventMethods = {
+    [K in keyof typeof Events]: (cb: (...args: ClientEvents[(typeof Events)[K]]) => void) => Client;
+};
 /** Main Fluxer bot client. Connects to the gateway, emits events, and provides REST access. */
 declare class Client extends EventEmitter {
     readonly options: ClientOptions;
@@ -685,7 +1198,11 @@ declare class Client extends EventEmitter {
     readonly guilds: GuildManager;
     readonly channels: ChannelManager;
     readonly users: Collection<string, User>;
+    /** Typed event handlers. Use client.events.MessageReactionAdd((reaction, user, messageId, channelId, emoji, userId) => {...}) or client.on(Events.MessageReactionAdd, ...). */
+    readonly events: ClientEventMethods;
+    /** The authenticated bot user. Null until READY is received. */
     user: ClientUser | null;
+    /** Timestamp when the client became ready. Null until READY is received. */
     readyAt: Date | null;
     private _ws;
     /** @param options - Token, REST config, WebSocket, presence, etc. */
@@ -707,13 +1224,14 @@ declare class Client extends EventEmitter {
      * Fetch a message by channel and message ID. Use when you have IDs (e.g. from a DB).
      * @param channelId - Snowflake of the channel
      * @param messageId - Snowflake of the message
-     * @returns The message, or null if not found
+     * @returns The message
+     * @throws FluxerError with MESSAGE_NOT_FOUND if the message does not exist
      * @deprecated Use channel.messages.fetch(messageId). For IDs-only: (await client.channels.fetch(channelId))?.messages?.fetch(messageId)
      * @example
      * const channel = await client.channels.fetch(channelId);
      * const message = await channel?.messages?.fetch(messageId);
      */
-    fetchMessage(channelId: string, messageId: string): Promise<Message | null>;
+    fetchMessage(channelId: string, messageId: string): Promise<Message>;
     /**
      * Send a message to any channel by ID. Shorthand for client.channels.send().
      * Works even when the channel is not cached.
@@ -750,13 +1268,137 @@ declare class Client extends EventEmitter {
     static get Routes(): typeof Routes;
 }
 
+/** Represents a custom emoji in a guild. */
+declare class GuildEmoji extends Base {
+    readonly client: Client;
+    readonly id: string;
+    readonly guildId: string;
+    name: string;
+    readonly animated: boolean;
+    /** @param data - API emoji from GET /guilds/{id}/emojis or guild emoji events */
+    constructor(client: Client, data: APIEmoji & {
+        guild_id?: string;
+    }, guildId: string);
+    /** CDN URL for this emoji image. */
+    get url(): string;
+    /** Emoji identifier for use in reactions: `name:id` */
+    get identifier(): string;
+    /** Delete this emoji. Requires Manage Emojis and Stickers permission. */
+    delete(): Promise<void>;
+    /**
+     * Edit this emoji's name.
+     * Requires Manage Emojis and Stickers permission.
+     */
+    edit(options: {
+        name: string;
+    }): Promise<GuildEmoji>;
+}
+
+/** Represents a custom sticker in a guild. */
+declare class GuildSticker extends Base {
+    readonly client: Client;
+    readonly id: string;
+    readonly guildId: string;
+    name: string;
+    description: string;
+    readonly tags: string[];
+    readonly animated: boolean;
+    /** @param data - API sticker from GET /guilds/{id}/stickers or guild sticker events */
+    constructor(client: Client, data: APISticker & {
+        guild_id?: string;
+    }, guildId: string);
+    /** CDN URL for this sticker image. */
+    get url(): string;
+    /** Delete this sticker. Requires Manage Emojis and Stickers permission. */
+    delete(): Promise<void>;
+    /**
+     * Edit this sticker's name and/or description.
+     * Requires Manage Emojis and Stickers permission.
+     */
+    edit(options: {
+        name?: string;
+        description?: string;
+    }): Promise<GuildSticker>;
+}
+
+interface FluxerErrorOptions {
+    code?: string;
+    cause?: Error;
+}
 declare class FluxerError extends Error {
-    constructor(message: string);
+    readonly code?: string;
+    constructor(message: string, options?: FluxerErrorOptions);
 }
 
 declare const ErrorCodes: {
     readonly ClientNotReady: "CLIENT_NOT_READY";
     readonly InvalidToken: "INVALID_TOKEN";
+    readonly AlreadyLoggedIn: "ALREADY_LOGGED_IN";
+    readonly ChannelNotFound: "CHANNEL_NOT_FOUND";
+    readonly MessageNotFound: "MESSAGE_NOT_FOUND";
+    readonly GuildNotFound: "GUILD_NOT_FOUND";
+    readonly MemberNotFound: "MEMBER_NOT_FOUND";
 };
 
-export { Base, CategoryChannel, Channel, ChannelManager, Client, type ClientEvents, ClientUser, DMChannel, ErrorCodes, Events, FluxerError, Guild, GuildChannel, GuildMember, LinkChannel, Message, type MessageEditOptions, MessageManager, MessageReaction, type PartialMessage, Role, TextChannel, User, VoiceChannel, Webhook, type WebhookSendOptions };
+interface CdnUrlOptions {
+    size?: number;
+    extension?: string;
+}
+/**
+ * Build a user avatar URL from raw API data.
+ * @param userId - The user's snowflake ID
+ * @param avatarHash - The avatar hash from the API, or null if no custom avatar
+ * @param options - Optional size and extension (default: png; auto-detects gif for a_ hashes)
+ * @returns The avatar URL, or null if no avatar hash
+ * @example
+ * const url = cdnAvatarURL(userData.id, userData.avatar, { size: 256 });
+ */
+declare function cdnAvatarURL(userId: string, avatarHash: string | null, options?: CdnUrlOptions): string | null;
+/**
+ * Build an avatar URL, or the default avatar when none set.
+ * @param userId - The user's snowflake ID
+ * @param avatarHash - The avatar hash from the API, or null
+ * @param options - Optional size and extension
+ * @returns The avatar URL (never null)
+ * @example
+ * const url = cdnDisplayAvatarURL(user.id, user.avatar, { size: 64 });
+ */
+declare function cdnDisplayAvatarURL(userId: string, avatarHash: string | null, options?: CdnUrlOptions): string;
+/**
+ * Build a user or guild banner URL from raw API data.
+ * @param resourceId - The user ID or guild ID
+ * @param bannerHash - The banner hash from the API, or null
+ * @param options - Optional size and extension (default: png; auto-detects gif for a_ hashes)
+ * @returns The banner URL, or null if no banner
+ * @example
+ * const url = cdnBannerURL(userData.id, profile.banner, { size: 512 });
+ */
+declare function cdnBannerURL(resourceId: string, bannerHash: string | null, options?: CdnUrlOptions): string | null;
+/**
+ * Build a guild member avatar URL (guild-specific avatar).
+ * @param guildId - The guild ID
+ * @param userId - The user ID
+ * @param avatarHash - The member avatar hash, or null
+ * @param options - Optional size and extension
+ * @returns The member avatar URL, or null if no guild avatar
+ * @example
+ * const url = cdnMemberAvatarURL(member.guild.id, member.id, member.avatar);
+ */
+declare function cdnMemberAvatarURL(guildId: string, userId: string, avatarHash: string | null, options?: CdnUrlOptions): string | null;
+/**
+ * Build a guild member banner URL (guild-specific banner).
+ * @param guildId - The guild ID
+ * @param userId - The user ID
+ * @param bannerHash - The member banner hash, or null
+ * @param options - Optional size and extension
+ * @returns The member banner URL, or null if no guild banner
+ */
+declare function cdnMemberBannerURL(guildId: string, userId: string, bannerHash: string | null, options?: CdnUrlOptions): string | null;
+/**
+ * Get the default avatar URL (used when user has no custom avatar).
+ * @param discriminatorIndex - Optional index 0-4 for default avatar variant
+ * @returns The default avatar URL
+ */
+declare function cdnDefaultAvatarURL(discriminatorIndex?: number): string;
+
+export { Base, CategoryChannel, type CdnUrlOptions, Channel, ChannelManager, Client, type ClientEventMethods, type ClientEvents, ClientUser, type CollectedReaction, DMChannel, ErrorCodes, Events, FluxerError, type FluxerErrorOptions, Guild, GuildBan, GuildChannel, GuildEmoji, GuildMember, GuildSticker, Invite, LinkChannel, Message, MessageCollector, type MessageCollectorEndReason, type MessageCollectorOptions, type MessageEditOptions, MessageManager, MessageReaction, type MessageSendOptions, type PartialMessage, ReactionCollector, type ReactionCollectorEndReason, type ReactionCollectorOptions, Role, TextChannel, User, VoiceChannel, Webhook, type WebhookSendOptions, cdnAvatarURL, cdnBannerURL, cdnDefaultAvatarURL, cdnDisplayAvatarURL, cdnMemberAvatarURL, cdnMemberBannerURL };