@fluxerjs/core 1.0.7 → 1.0.8

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Collection } from '@fluxerjs/collection';
 import * as _fluxerjs_types from '@fluxerjs/types';
-import { APIWebhook, APIChannelPartial, ChannelType, APIChannel, APIMessageAttachment, APIMessage, APIEmbed, APIUserPartial, 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 { EmbedBuilder } from '@fluxerjs/builders';
 export { AttachmentBuilder, EmbedBuilder, MessagePayload } from '@fluxerjs/builders';
@@ -12,6 +12,24 @@ declare abstract class Base {
     abstract readonly client: Client;
 }
 
+/**
+ * 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 */
@@ -72,6 +90,12 @@ declare class Webhook extends Base {
 
 /** 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;
@@ -85,6 +109,11 @@ declare abstract class Channel extends Base {
      * @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;
@@ -121,6 +150,15 @@ declare class TextChannel extends GuildChannel {
         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,6 +184,89 @@ declare class DMChannel extends Channel {
         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;
+    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[]>;
 }
 
 /** Options for editing a message (content and/or embeds). */
@@ -167,9 +288,35 @@ declare class Message extends Base {
     readonly editedAt: Date | null;
     pinned: boolean;
     readonly attachments: Collection<string, APIMessageAttachment>;
-    channel?: Channel;
+    /** 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
@@ -183,29 +330,41 @@ declare class Message extends Base {
      * @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.
-     * @param emoji - Unicode emoji (e.g. "👍") or custom { name, id } or "name:id" string
+     * 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 (e.g. `👍`) or custom emoji `{ name, id }`
+     * @param emoji - Unicode emoji, custom `{ name, id }`, `:name:`, `name:id`, or `<:name:id>`
      */
     react(emoji: string | {
         name: string;
-        id: 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 or custom `{ name, id }`
+     * @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;
+        id?: string;
+        animated?: boolean;
     }, userId?: string): Promise<void>;
     /**
      * Remove all reactions from this message.
@@ -214,11 +373,12 @@ declare class Message extends Base {
     removeAllReactions(): Promise<void>;
     /**
      * Remove all reactions of a specific emoji from this message.
-     * @param emoji - Unicode emoji or custom `{ name, id }`. Requires moderator permissions.
+     * @param emoji - Unicode emoji, custom `{ name, id }`, `:name:`, `name:id`, or `<:name:id>`. Requires moderator permissions.
      */
     removeReactionEmoji(emoji: string | {
         name: string;
-        id: string;
+        id?: string;
+        animated?: boolean;
     }): Promise<void>;
 }
 
@@ -233,6 +393,8 @@ declare class User extends Base {
     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`)
@@ -262,36 +424,6 @@ declare class User extends Base {
     }): Promise<Message>;
 }
 
-/** 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;
-    members: Collection<string, GuildMember>;
-    channels: Collection<string, GuildChannel>;
-    /** @param data - API guild from GET /guilds/{id} or gateway GUILD_CREATE */
-    constructor(client: Client, data: APIGuild);
-    /** 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;
-    /**
-     * 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[]>;
-}
-
 /** Represents a member of a guild. */
 declare class GuildMember extends Base {
     readonly client: Client;
@@ -322,6 +454,95 @@ declare class GuildMember extends Base {
     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 {
     rest?: Partial<ConstructorParameters<typeof REST>[0]>;
     intents?: number;
@@ -347,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";
@@ -355,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";
 };
@@ -371,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];
@@ -388,17 +637,44 @@ 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];
 }
@@ -406,14 +682,51 @@ interface ClientEvents {
 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;
     /**
@@ -446,4 +759,4 @@ declare const ErrorCodes: {
     readonly InvalidToken: "INVALID_TOKEN";
 };
 
-export { Base, CategoryChannel, Channel, Client, type ClientEvents, ClientUser, DMChannel, 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 };