@fluxerjs/core 1.0.6 → 1.0.8

package/dist/index.d.ts

@@ -1,7 +1,7 @@
+import { Collection } from '@fluxerjs/collection';
 import * as _fluxerjs_types from '@fluxerjs/types';
-import { APIUserPartial, APIMessageAttachment, APIMessage, APIEmbed, APIWebhook, ChannelType, APIChannelPartial, APIChannel, APIGuild, APIGuildMember, GatewayPresenceUpdateData, GatewaySendPayload, Routes, GatewayMessageReactionAddDispatchData, GatewayMessageReactionRemoveDispatchData, GatewayMessageReactionRemoveAllDispatchData, GatewayMessageReactionRemoveEmojiDispatchData, GatewayVoiceStateUpdateDispatchData, GatewayVoiceServerUpdateDispatchData } 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 { Collection } from '@fluxerjs/collection';
 import { EmbedBuilder } from '@fluxerjs/builders';
 export { AttachmentBuilder, EmbedBuilder, MessagePayload } from '@fluxerjs/builders';
 import { EventEmitter } from 'events';
@@ -12,56 +12,35 @@ declare abstract class Base {
     abstract readonly client: Client;
 }
 
-declare class User extends Base {
-    readonly client: Client;
-    readonly id: string;
-    username: string;
-    discriminator: string;
-    globalName: string | null;
-    avatar: string | null;
-    readonly bot: boolean;
-    constructor(client: Client, data: APIUserPartial);
-    avatarURL(options?: {
-        size?: number;
-        extension?: string;
-    }): string | null;
-    displayAvatarURL(options?: {
-        size?: number;
-    }): string;
-    toString(): string;
-}
-
-/** Options for editing a message (content and/or embeds). */
-interface MessageEditOptions {
-    content?: string;
-    embeds?: (APIEmbed | EmbedBuilder)[];
-}
-declare class Message extends Base {
-    readonly client: Client;
-    readonly id: string;
-    readonly channelId: string;
-    readonly guildId: string | null;
-    readonly author: User;
-    content: string;
-    readonly createdAt: Date;
-    readonly editedAt: Date | null;
-    pinned: boolean;
-    readonly attachments: Collection<string, APIMessageAttachment>;
-    channel?: Channel;
-    constructor(client: Client, data: APIMessage);
-    reply(options: string | {
-        content?: string;
-        embeds?: APIEmbed[];
-    }): Promise<Message>;
-    edit(options: MessageEditOptions): Promise<Message>;
-    delete(): Promise<void>;
+/**
+ * Manages messages for a channel. Access via channel.messages.
+ * @example
+ * const message = await channel.messages.fetch(messageId);
+ * if (message) await message.edit({ content: 'Updated!' });
+ */
+declare class MessageManager {
+    private readonly client;
+    private readonly channelId;
+    constructor(client: Client, channelId: string);
+    /**
+     * Fetch a message by ID from this channel.
+     * @param messageId - Snowflake of the message
+     * @returns The message, or null if not found
+     */
+    fetch(messageId: string): Promise<Message | null>;
 }
 
+/** Options for sending a message via webhook. */
 interface WebhookSendOptions {
+    /** Message text content */
     content?: string;
+    /** Embed objects (use EmbedBuilder.toJSON()) */
     embeds?: Array<Record<string, unknown>>;
+    /** Override the webhook's default username */
     username?: string;
+    /** Override the webhook's default avatar URL */
     avatar_url?: string;
+    /** Text-to-speech */
     tts?: boolean;
 }
 /**
@@ -77,6 +56,7 @@ declare class Webhook extends Base {
     avatar: string | null;
     /** Present only when webhook was created via createWebhook(); not returned when fetching. */
     readonly token: string | null;
+    /** @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;
     });
@@ -88,12 +68,18 @@ declare class Webhook extends Base {
      */
     send(options: string | WebhookSendOptions): Promise<void>;
     /**
-     * Fetch a webhook by ID using bot auth. The returned webhook will not have a token (cannot send).
+     * 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 fetch(client: Client, webhookId: string): Promise<Webhook>;
     /**
      * Create a Webhook instance from an ID and token (e.g. from a stored webhook URL).
-     * Useful when you have the token from a previous createWebhook() call.
+     * @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: Client, webhookId: string, token: string, options?: {
         channelId?: string;
@@ -102,12 +88,32 @@ declare class Webhook extends Base {
     }): Webhook;
 }
 
+/** Base class for all channel types. */
 declare abstract class Channel extends Base {
+    /** Whether this channel has a send method (TextChannel, DMChannel). */
+    isSendable(): this is TextChannel | DMChannel;
+    /** Whether this channel is a DM or Group DM. */
+    isDM(): boolean;
+    /** Whether this channel is voice-based (VoiceChannel). */
+    isVoice(): boolean;
+    /** Create a DM channel from API data (type DM or GroupDM). */
+    static createDM(client: Client, data: APIChannelPartial): DMChannel;
     readonly client: Client;
     readonly id: string;
     type: ChannelType;
+    /** @param data - API channel from GET /channels/{id} or GET /guilds/{id}/channels */
     constructor(client: Client, data: APIChannelPartial);
+    /**
+     * Create the appropriate channel subclass from API data.
+     * @param client - The client instance
+     * @param data - Channel data from the API
+     */
     static from(client: Client, data: APIChannel | APIChannelPartial): GuildChannel | TextChannel | null;
+    /**
+     * Create a channel from API data, including DM and GroupDM.
+     * Used by ChannelManager.fetch() for GET /channels/{id}.
+     */
+    static fromOrCreate(client: Client, data: APIChannel | APIChannelPartial): TextChannel | DMChannel | GuildChannel | null;
 }
 declare class GuildChannel extends Channel {
     readonly guildId: string;
@@ -115,12 +121,19 @@ declare class GuildChannel extends Channel {
     position?: number;
     parentId: string | null;
     constructor(client: Client, data: APIChannel);
-    /** Create a webhook in this channel. Returns the webhook with token (required for send()). */
+    /**
+     * 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.
+     */
     createWebhook(options: {
         name: string;
         avatar?: string | null;
     }): Promise<Webhook>;
-    /** Fetch all webhooks in this channel. Returned webhooks do not include the token (cannot send). */
+    /**
+     * Fetch all webhooks in this channel.
+     * @returns Webhooks (includes token when listing from channel; can send via send())
+     */
     fetchWebhooks(): Promise<Webhook[]>;
 }
 declare class TextChannel extends GuildChannel {
@@ -129,10 +142,23 @@ declare class TextChannel extends GuildChannel {
     rateLimitPerUser?: number;
     lastMessageId?: string | null;
     constructor(client: Client, data: APIChannel);
+    /**
+     * Send a message to this channel.
+     * @param options - Text content or object with `content` and/or `embeds`
+     */
     send(options: string | {
         content?: string;
         embeds?: unknown[];
     }): Promise<Message>;
+    /** Message manager for this channel. Use channel.messages.fetch(messageId). */
+    get messages(): MessageManager;
+    /**
+     * 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>;
 }
 declare class CategoryChannel extends GuildChannel {
 }
@@ -146,7 +172,50 @@ declare class LinkChannel extends GuildChannel {
     url?: string | null;
     constructor(client: Client, data: APIChannel);
 }
+/** DM channel (direct message between bot and a user). */
+declare class DMChannel extends Channel {
+    lastMessageId?: string | null;
+    constructor(client: Client, data: APIChannelPartial);
+    /**
+     * Send a message to this DM channel.
+     * @param options - Text content or object with `content` and/or `embeds`
+     */
+    send(options: string | {
+        content?: string;
+        embeds?: unknown[];
+    }): Promise<Message>;
+    /** Message manager for this channel. Use channel.messages.fetch(messageId). */
+    get messages(): MessageManager;
+    /**
+     * 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>;
+}
+
+/** Represents a role in a guild. */
+declare class Role 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;
+}
 
+/** Represents a Fluxer guild (server). */
 declare class Guild extends Base {
     readonly client: Client;
     readonly id: string;
@@ -156,17 +225,206 @@ declare class Guild extends Base {
     readonly ownerId: string;
     members: Collection<string, GuildMember>;
     channels: Collection<string, GuildChannel>;
-    constructor(client: Client, data: APIGuild);
+    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[]>;
 }
 
+/** Options for editing a message (content and/or embeds). */
+interface MessageEditOptions {
+    /** New text content */
+    content?: string;
+    /** New embeds (replaces existing) */
+    embeds?: (APIEmbed | EmbedBuilder)[];
+}
+/** Represents a message in a channel. */
+declare class Message extends Base {
+    readonly client: Client;
+    readonly id: string;
+    readonly channelId: string;
+    readonly guildId: string | null;
+    readonly author: User;
+    content: string;
+    readonly createdAt: Date;
+    readonly editedAt: Date | null;
+    pinned: boolean;
+    readonly attachments: Collection<string, APIMessageAttachment>;
+    /** 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. */
+    get guild(): Guild | null;
+    /** @param data - API message from POST/PATCH /channels/{id}/messages or gateway MESSAGE_CREATE */
+    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
+     * @example
+     * await message.send('Pong!');
+     * await message.send({ embeds: [embed.toJSON()] });
+     */
+    send(options: string | {
+        content?: string;
+        embeds?: APIEmbed[];
+    }): 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)
+     * @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.toJSON()] });
+     */
+    sendTo(channelId: string, options: string | {
+        content?: string;
+        embeds?: APIEmbed[];
+    }): Promise<Message>;
+    /**
+     * Reply to this message.
+     * @param options - Text content or object with content and/or embeds
+     */
+    reply(options: string | {
+        content?: string;
+        embeds?: APIEmbed[];
+    }): Promise<Message>;
+    /**
+     * Edit this message. Only the author (or admins) can edit.
+     * @param options - New content and/or embeds
+     */
+    edit(options: MessageEditOptions): Promise<Message>;
+    /**
+     * 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
+     * @example
+     * const updated = await message.fetch();
+     * if (updated) console.log('Latest content:', updated.content);
+     */
+    fetch(): Promise<Message | null>;
+    /** Delete this message. */
+    delete(): 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.
+     */
+    private static formatEmoji;
+    private resolveEmojiForReaction;
+    /**
+     * Add a reaction to this message (as the bot).
+     * @param emoji - Unicode emoji, custom `{ name, id }`, `:name:`, `name:id`, or `<:name:id>`
+     */
+    react(emoji: string | {
+        name: string;
+        id?: string;
+        animated?: boolean;
+    }): Promise<void>;
+    /**
+     * 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)
+     */
+    removeReaction(emoji: string | {
+        name: string;
+        id?: string;
+        animated?: boolean;
+    }, userId?: string): Promise<void>;
+    /**
+     * Remove all reactions from this message.
+     * Requires moderator permissions.
+     */
+    removeAllReactions(): Promise<void>;
+    /**
+     * 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.
+     */
+    removeReactionEmoji(emoji: string | {
+        name: string;
+        id?: string;
+        animated?: boolean;
+    }): Promise<void>;
+}
+
+/** Represents a user (or bot) on Fluxer. */
+declare class User extends Base {
+    readonly client: Client;
+    readonly id: string;
+    username: string;
+    discriminator: string;
+    globalName: string | null;
+    avatar: string | null;
+    readonly bot: boolean;
+    /** @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`)
+     */
+    avatarURL(options?: {
+        size?: number;
+        extension?: string;
+    }): string | null;
+    /** Get the avatar URL, or the default avatar if none set. */
+    displayAvatarURL(options?: {
+        size?: number;
+    }): string;
+    /** Returns a mention string (e.g. `<@123456>`). */
+    toString(): string;
+    /**
+     * Create or get a DM channel with this user.
+     * Returns the DM channel; use {@link DMChannel.send} to send messages.
+     */
+    createDM(): Promise<DMChannel>;
+    /**
+     * 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>;
+}
+
+/** Represents a member of a guild. */
 declare class GuildMember extends Base {
     readonly client: Client;
     readonly id: string;
@@ -176,10 +434,113 @@ declare class GuildMember extends Base {
     readonly roles: string[];
     readonly joinedAt: Date;
     communicationDisabledUntil: Date | 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;
+    /**
+     * Add a role to this member.
+     * @param roleId - The role ID to add
+     * Requires Manage Roles permission.
+     */
+    addRole(roleId: string): Promise<void>;
+    /**
+     * Remove a role from this member.
+     * @param roleId - The role ID to remove
+     * Requires Manage Roles permission.
+     */
+    removeRole(roleId: string): Promise<void>;
+}
+
+/** Represents a reaction added to or removed from a message. */
+declare class MessageReaction 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;
+    /**
+     * Fetch the message this reaction belongs to.
+     * Use when you need to edit, delete, or otherwise interact with the message.
+     */
+    fetchMessage(): Promise<Message | null>;
+}
+
+/** Minimal message data for MessageDelete when the full message is not available. */
+interface PartialMessage {
+    id: string;
+    channelId: string;
+    channel?: Channel | null;
+}
+
+/**
+ * Manages channels with fetch and send.
+ * Extends Collection so you can use .get(), .set(), .filter(), etc.
+ */
+declare class ChannelManager extends Collection<string, Channel> {
+    private readonly client;
+    constructor(client: Client);
+    /**
+     * 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
+     * @example
+     * const channel = await client.channels.fetch(channelId);
+     * if (channel?.isSendable()) await channel.send('Hello!');
+     */
+    fetch(channelId: string): Promise<Channel | null>;
+    /**
+     * 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
+     * @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>;
+    /**
+     * 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
+     * @returns The created message
+     * @example
+     * await client.channels.send(logChannelId, 'User joined!');
+     * await client.channels.send(channelId, { embeds: [embed.toJSON()] });
+     */
+    send(channelId: string, payload: string | {
+        content?: string;
+        embeds?: _fluxerjs_types.APIEmbed[];
+    }): Promise<Message>;
+}
+
+/**
+ * Manages guilds with fetch.
+ * Extends Collection so you can use .get(), .set(), .filter(), etc.
+ */
+declare class GuildManager extends Collection<string, Guild> {
+    private readonly client;
+    constructor(client: Client);
+    /**
+     * Fetch a guild by ID from the API (or return from cache if present).
+     * @param guildId - Snowflake of the guild
+     * @returns The guild, or null if not found
+     * @example
+     * const guild = await client.guilds.fetch(guildId);
+     * if (guild) console.log(guild.name);
+     */
+    fetch(guildId: string): Promise<Guild | null>;
 }
 
 interface ClientOptions {
@@ -207,6 +568,7 @@ declare const Events: {
     readonly MessageCreate: "messageCreate";
     readonly MessageUpdate: "messageUpdate";
     readonly MessageDelete: "messageDelete";
+    readonly MessageDeleteBulk: "messageDeleteBulk";
     readonly MessageReactionAdd: "messageReactionAdd";
     readonly MessageReactionRemove: "messageReactionRemove";
     readonly MessageReactionRemoveAll: "messageReactionRemoveAll";
@@ -215,15 +577,34 @@ declare const Events: {
     readonly GuildCreate: "guildCreate";
     readonly GuildUpdate: "guildUpdate";
     readonly GuildDelete: "guildDelete";
-    readonly ChannelCreate: "channelCreate";
-    readonly ChannelUpdate: "channelUpdate";
-    readonly ChannelDelete: "channelDelete";
+    readonly GuildBanAdd: "guildBanAdd";
+    readonly GuildBanRemove: "guildBanRemove";
+    readonly GuildEmojisUpdate: "guildEmojisUpdate";
+    readonly GuildStickersUpdate: "guildStickersUpdate";
+    readonly GuildIntegrationsUpdate: "guildIntegrationsUpdate";
     readonly GuildMemberAdd: "guildMemberAdd";
     readonly GuildMemberUpdate: "guildMemberUpdate";
     readonly GuildMemberRemove: "guildMemberRemove";
+    readonly GuildRoleCreate: "guildRoleCreate";
+    readonly GuildRoleUpdate: "guildRoleUpdate";
+    readonly GuildRoleDelete: "guildRoleDelete";
+    readonly GuildScheduledEventCreate: "guildScheduledEventCreate";
+    readonly GuildScheduledEventUpdate: "guildScheduledEventUpdate";
+    readonly GuildScheduledEventDelete: "guildScheduledEventDelete";
+    readonly ChannelCreate: "channelCreate";
+    readonly ChannelUpdate: "channelUpdate";
+    readonly ChannelDelete: "channelDelete";
+    readonly ChannelPinsUpdate: "channelPinsUpdate";
+    readonly InviteCreate: "inviteCreate";
+    readonly InviteDelete: "inviteDelete";
+    readonly TypingStart: "typingStart";
+    readonly UserUpdate: "userUpdate";
+    readonly PresenceUpdate: "presenceUpdate";
     readonly VoiceStateUpdate: "voiceStateUpdate";
     readonly VoiceServerUpdate: "voiceServerUpdate";
     readonly VoiceStatesSync: "voiceStatesSync";
+    readonly WebhooksUpdate: "webhooksUpdate";
+    readonly Resumed: "resumed";
     readonly Error: "error";
     readonly Debug: "debug";
 };
@@ -231,16 +612,24 @@ declare const Events: {
 interface ClientEvents {
     [Events.Ready]: [];
     [Events.MessageCreate]: [message: Message];
-    [Events.MessageUpdate]: [oldMessage: Message | null, newMessage: Message];
-    [Events.MessageDelete]: [message: Message | {
-        id: string;
-        channelId: string;
-    }];
-    [Events.MessageReactionAdd]: [data: GatewayMessageReactionAddDispatchData];
-    [Events.MessageReactionRemove]: [data: GatewayMessageReactionRemoveDispatchData];
+    [Events.MessageUpdate]: [
+        oldMessage: Message | null,
+        newMessage: Message
+    ];
+    [Events.MessageDelete]: [message: PartialMessage];
+    [Events.MessageReactionAdd]: [
+        reaction: MessageReaction,
+        user: User
+    ];
+    [Events.MessageReactionRemove]: [
+        reaction: MessageReaction,
+        user: User
+    ];
     [Events.MessageReactionRemoveAll]: [data: GatewayMessageReactionRemoveAllDispatchData];
     [Events.MessageReactionRemoveEmoji]: [data: GatewayMessageReactionRemoveEmojiDispatchData];
-    [Events.InteractionCreate]: [interaction: _fluxerjs_types.APIApplicationCommandInteraction];
+    [Events.InteractionCreate]: [
+        interaction: _fluxerjs_types.APIApplicationCommandInteraction
+    ];
     [Events.GuildCreate]: [guild: Guild];
     [Events.GuildUpdate]: [oldGuild: Guild, newGuild: Guild];
     [Events.GuildDelete]: [guild: Guild];
@@ -248,36 +637,113 @@ interface ClientEvents {
     [Events.ChannelUpdate]: [oldChannel: Channel, newChannel: Channel];
     [Events.ChannelDelete]: [channel: Channel];
     [Events.GuildMemberAdd]: [member: GuildMember];
-    [Events.GuildMemberUpdate]: [oldMember: GuildMember, newMember: GuildMember];
+    [Events.GuildMemberUpdate]: [
+        oldMember: GuildMember,
+        newMember: GuildMember
+    ];
     [Events.GuildMemberRemove]: [member: GuildMember];
     [Events.VoiceStateUpdate]: [data: GatewayVoiceStateUpdateDispatchData];
     [Events.VoiceServerUpdate]: [data: GatewayVoiceServerUpdateDispatchData];
-    [Events.VoiceStatesSync]: [data: {
-        guildId: string;
-        voiceStates: Array<{
-            user_id: string;
-            channel_id: string | null;
-        }>;
-    }];
+    [Events.VoiceStatesSync]: [
+        data: {
+            guildId: string;
+            voiceStates: Array<{
+                user_id: string;
+                channel_id: string | null;
+            }>;
+        }
+    ];
+    [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.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.TypingStart]: [data: _fluxerjs_types.GatewayTypingStartDispatchData];
+    [Events.UserUpdate]: [data: _fluxerjs_types.GatewayUserUpdateDispatchData];
+    [Events.PresenceUpdate]: [data: unknown];
+    [Events.WebhooksUpdate]: [data: unknown];
+    [Events.Resumed]: [];
     [Events.Error]: [error: Error];
     [Events.Debug]: [message: string];
 }
+/** Main Fluxer bot client. Connects to the gateway, emits events, and provides REST access. */
 declare class Client extends EventEmitter {
     readonly options: ClientOptions;
     readonly rest: REST;
-    readonly guilds: Collection<string, Guild>;
-    readonly channels: Collection<string, Channel>;
+    readonly guilds: GuildManager;
+    readonly channels: ChannelManager;
     readonly users: Collection<string, User>;
     user: ClientUser | null;
     readyAt: Date | null;
     private _ws;
+    /** @param options - Token, REST config, WebSocket, presence, etc. */
     constructor(options?: ClientOptions);
+    /**
+     * Resolve an emoji argument to the API format (unicode or "name:id").
+     * Supports: <:name:id>, :name:, name:id, { name, id }, unicode.
+     * When id is missing (e.g. :name:), fetches guild emojis if guildId provided.
+     * @param emoji - Emoji string or object
+     * @param guildId - Guild ID for resolving custom emoji by name (required when id is missing)
+     * @returns API-formatted string for reactions
+     */
+    resolveEmoji(emoji: string | {
+        name: string;
+        id?: string;
+        animated?: boolean;
+    }, guildId?: string | null): Promise<string>;
+    /**
+     * 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
+     * @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>;
+    /**
+     * Send a message to any channel by ID. Shorthand for client.channels.send().
+     * Works even when the channel is not cached.
+     */
+    sendToChannel(channelId: string, payload: string | {
+        content?: string;
+        embeds?: _fluxerjs_types.APIEmbed[];
+    }): Promise<Message>;
+    /**
+     * Get or create a User from API data. Caches in client.users.
+     * Updates existing user's username, avatar, etc. when fresh data is provided.
+     */
+    getOrCreateUser(data: APIUserPartial): User;
+    /** WebSocket manager. Throws if not logged in. */
     get ws(): WebSocketManager;
-    /** Send a payload to the gateway (e.g. Voice State Update). Uses shard 0 when single-shard. */
+    /**
+     * Send a payload to the gateway (e.g. Voice State Update).
+     * @param shardId - Shard ID (use 0 for single-shard)
+     * @param payload - Gateway payload to send
+     */
     sendToGateway(shardId: number, payload: GatewaySendPayload): void;
     private handleDispatch;
+    /**
+     * Connect to the Fluxer gateway and authenticate.
+     * @param token - Bot token (e.g. from FLUXER_BOT_TOKEN)
+     */
     login(token: string): Promise<string>;
+    /** Disconnect from the gateway and clear cached data. */
     destroy(): Promise<void>;
+    /** Returns true if the client has received Ready and `user` is set. */
     isReady(): this is Client & {
         user: NonNullable<Client['user']>;
     };
@@ -293,4 +759,4 @@ declare const ErrorCodes: {
     readonly InvalidToken: "INVALID_TOKEN";
 };
 
-export { Base, CategoryChannel, Channel, Client, type ClientEvents, ClientUser, ErrorCodes, Events, FluxerError, Guild, GuildChannel, GuildMember, LinkChannel, Message, type MessageEditOptions, TextChannel, User, VoiceChannel, Webhook, type WebhookSendOptions };
+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 };