@fluxerjs/core 1.0.7 → 1.0.9

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-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, APIWebhookUpdateRequest, APIWebhookTokenUpdateRequest, APIChannel, APIChannelPartial, ChannelType, APIMessageAttachment, MessageType, APIEmbed, APIMessageSticker, APIMessageReaction, APIMessageReference, APIMessageSnapshot, APIMessageCall, APIMessage, APIUserPartial, APIGuildMember, APIRole, APIGuild, APIGuildAuditLog, APIGuildPartial, APIInvite, APIBan, GatewayReactionEmoji, GatewayMessageReactionAddDispatchData, GatewayMessageReactionRemoveDispatchData, GatewayPresenceUpdateData, GatewaySendPayload, Routes, GatewayMessageReactionRemoveAllDispatchData, GatewayMessageReactionRemoveEmojiDispatchData, GatewayVoiceStateUpdateDispatchData, GatewayVoiceServerUpdateDispatchData, APIEmoji, APISticker } 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,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 */
@@ -33,7 +51,7 @@ 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. */
@@ -44,6 +62,12 @@ declare class Webhook extends Base {
     });
     /** 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).
      * @throws Error if token is not available
@@ -72,6 +96,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 +115,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 +156,20 @@ 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 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>;
 }
 declare class CategoryChannel extends GuildChannel {
 }
@@ -146,6 +195,20 @@ 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 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>;
 }
 
 /** Options for editing a message (content and/or embeds). */
@@ -167,9 +230,46 @@ declare class Message extends Base {
     readonly editedAt: Date | null;
     pinned: boolean;
     readonly attachments: Collection<string, APIMessageAttachment>;
-    channel?: Channel;
+    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;
+    /** 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 +283,45 @@ 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>;
+    /** 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.
-     * @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 +330,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 +350,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,6 +381,62 @@ declare class User extends Base {
     }): Promise<Message>;
 }
 
+/** Represents a member of a guild. */
+declare class GuildMember extends Base {
+    readonly client: Client;
+    readonly id: string;
+    readonly user: User;
+    readonly guild: Guild;
+    nick: string | null;
+    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;
+    /**
+     * 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 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;
@@ -272,8 +447,11 @@ declare class Guild extends Base {
     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);
+    constructor(client: Client, data: APIGuild & {
+        roles?: APIRole[];
+    });
     /** Get the guild icon URL, or null if no icon. */
     iconURL(options?: {
         size?: number;
@@ -282,44 +460,184 @@ declare class Guild extends Base {
     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 guild audit logs. Requires View Audit Log permission.
+     * @param options - Optional limit, before, after, user_id, action_type for filtering
+     */
+    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[]>;
 }
 
-/** Represents a member of a guild. */
-declare class GuildMember extends Base {
+/** Represents an invite to a guild or channel. */
+declare class Invite extends Base {
     readonly client: Client;
-    readonly id: string;
+    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>;
+}
+
+/** Represents a ban in a guild. */
+declare class GuildBan extends Base {
+    readonly client: Client;
+    readonly guildId: string;
     readonly user: User;
-    readonly guild: Guild;
-    nick: string | null;
-    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 & {
+    readonly reason: string | null;
+    /** @param data - API ban from GET /guilds/{id}/bans or gateway GUILD_BAN_ADD */
+    constructor(client: Client, data: APIBan & {
         guild_id?: string;
-    }, guild: Guild);
-    /** Nickname, or global name, or username. */
-    get displayName(): string;
+    }, guildId: string);
     /**
-     * Add a role to this member.
-     * @param roleId - The role ID to add
-     * Requires Manage Roles permission.
+     * Remove this ban (unban the user).
+     * Requires Ban Members permission.
      */
-    addRole(roleId: string): Promise<void>;
+    unban(): 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;
     /**
-     * Remove a role from this member.
-     * @param roleId - The role ID to remove
-     * Requires Manage Roles permission.
+     * Fetch the message this reaction belongs to.
+     * Use when you need to edit, delete, or otherwise interact with the message.
      */
-    removeRole(roleId: string): Promise<void>;
+    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 {
@@ -347,6 +665,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 +674,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 +709,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 +734,46 @@ 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]: [ban: GuildBan];
+    [Events.GuildBanRemove]: [ban: GuildBan];
+    [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]: [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.Resumed]: [];
     [Events.Error]: [error: Error];
     [Events.Debug]: [message: string];
 }
@@ -406,14 +781,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;
     /**
@@ -437,6 +849,59 @@ 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>;
+}
+
 declare class FluxerError extends Error {
     constructor(message: string);
 }
@@ -446,4 +911,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, GuildBan, GuildChannel, GuildEmoji, GuildMember, GuildSticker, Invite, LinkChannel, Message, type MessageEditOptions, MessageManager, MessageReaction, type PartialMessage, Role, TextChannel, User, VoiceChannel, Webhook, type WebhookSendOptions };