@erinjs/core 1.0.0 → 1.2.4

package/dist/index.d.mts

@@ -0,0 +1,2084 @@
+import { EventEmitter } from 'events';
+import { REST } from '@erinjs/rest';
+import { WebSocketManager } from '@erinjs/ws';
+import { APIEmbed, APIUserPartial, APIRole, RESTUpdateRoleBody, APIGuildMember, APIWebhook, APIWebhookUpdateRequest, APIWebhookTokenUpdateRequest, APIWebhookEditMessageRequest, APIBan, APIEmoji, APISticker, APIGuildPartial, APIChannelPartial, APIInvite, GuildFeature, GuildVerificationLevel, DefaultMessageNotifications, GuildExplicitContentFilter, GuildMFALevel, APIGuild, RESTCreateRoleBody, APIGuildAuditLog, APIVanityURL, GatewayReactionEmoji, GatewayMessageReactionAddDispatchData, GatewayMessageReactionRemoveDispatchData, APIMessageAttachment, MessageType, APIMessageSticker, APIMessageReaction, APIMessageReference, APIMessageSnapshot, APIMessageCall, APIMessage, APIChannelOverwrite, APIChannel, ChannelType, GatewayPresenceUpdateData, APIProfileResponse, GatewayMessageReactionRemoveAllDispatchData, GatewayMessageReactionRemoveEmojiDispatchData, APIApplicationCommandInteraction, GatewayGuildMembersChunkDispatchData, GatewayVoiceStateUpdateDispatchData, GatewayVoiceServerUpdateDispatchData, GatewayMessageDeleteBulkDispatchData, GatewayGuildEmojisUpdateDispatchData, GatewayGuildStickersUpdateDispatchData, GatewayGuildIntegrationsUpdateDispatchData, GatewayGuildRoleCreateDispatchData, GatewayGuildRoleUpdateDispatchData, GatewayGuildRoleDeleteDispatchData, GatewayGuildScheduledEventCreateDispatchData, GatewayGuildScheduledEventUpdateDispatchData, GatewayGuildScheduledEventDeleteDispatchData, GatewayChannelPinsUpdateDispatchData, GatewayInviteDeleteDispatchData, GatewayTypingStartDispatchData, GatewayUserUpdateDispatchData, GatewayPresenceUpdateDispatchData, GatewayWebhooksUpdateDispatchData, APIInstance, APIGatewayBotResponse, GatewaySendPayload, Routes } from '@erinjs/types';
+export { GatewayOpcodes, MessageAttachmentFlags, Routes } from '@erinjs/types';
+import { Collection } from '@erinjs/collection';
+import { EmbedBuilder } from '@erinjs/builders';
+export { AttachmentBuilder, EmbedBuilder, MessagePayload } from '@erinjs/builders';
+import { PermissionsBitField, PermissionResolvable, BitField } from '@erinjs/util';
+export { PermissionFlags, PermissionResolvable, PermissionString, PermissionsBitField, UserFlagsBitField, UserFlagsBits, UserFlagsResolvable, UserFlagsString, parsePrefixCommand, parseUserMention, resolvePermissionsToBitfield, resolveTenorToImageUrl } from '@erinjs/util';
+
+/** Resolved file data (after URL fetch). Used internally by REST layer. */
+interface ResolvedMessageFile {
+    name: string;
+    data: Blob | ArrayBuffer | Uint8Array | Buffer;
+    filename?: string;
+}
+/** File data for message attachment uploads. Use `data` for buffers or `url` to fetch from a URL. */
+type MessageFileData = {
+    name: string;
+    data: Blob | ArrayBuffer | Uint8Array | Buffer;
+    filename?: string;
+} | {
+    name: string;
+    url: string;
+    filename?: string;
+};
+/** Attachment metadata for file uploads (id matches FormData index). */
+interface MessageAttachmentMeta {
+    id: number;
+    filename: string;
+    title?: string | null;
+    description?: string | null;
+    /** MessageAttachmentFlags: IS_SPOILER (8), CONTAINS_EXPLICIT_MEDIA (16), IS_ANIMATED (32) */
+    flags?: number;
+}
+/** Options for sending a message (content, embeds, files). Used by Message.send, Channel.send, ChannelManager.send.
+ * EmbedBuilder instances are auto-converted to API format—no need to call .toJSON().
+ */
+type MessageSendOptions = {
+    content?: string;
+    /** EmbedBuilder instances are auto-converted; raw APIEmbed also supported. */
+    embeds?: (APIEmbed | EmbedBuilder)[];
+    /** File attachments. When present, request uses multipart/form-data. */
+    files?: MessageFileData[];
+    /** Attachment metadata for files (id = index). Use when files are provided. */
+    attachments?: MessageAttachmentMeta[];
+    /** Message flags (e.g. MessageFlags.SuppressNotifications for reply without ping). */
+    flags?: number;
+};
+/** API-ready body from MessageSendOptions or text content (serializes EmbedBuilder, includes attachments when files present). */
+interface SendBodyResult {
+    content?: string;
+    embeds?: APIEmbed[];
+    attachments?: Array<{
+        id: number;
+        filename: string;
+        title?: string | null;
+        description?: string | null;
+        flags?: number;
+    }>;
+    /** Message flags (e.g. SuppressNotifications for reply without ping). */
+    flags?: number;
+}
+
+/** Base class for all Fluxer structures. Provides the client reference. */
+declare abstract class Base {
+    /** The client instance this structure belongs to. */
+    abstract readonly client: Client;
+}
+
+/** 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;
+    /** RGB avatar color (e.g. 7577782). Null if not set. */
+    avatarColor: number | null;
+    /** Public flags bitfield. Null if not set. */
+    flags: number | null;
+    /** Whether this is an official system user. */
+    readonly system: boolean;
+    /** Banner hash (from profile, member, or invite context). Null when not available. */
+    banner: string | null;
+    /** @param data - API user from message author, GET /users/{id}, or GET /users/@me */
+    constructor(client: Client, data: APIUserPartial);
+    /** Update mutable fields from fresh API data. Used by getOrCreateUser cache. */
+    _patch(data: APIUserPartial): void;
+    /**
+     * Get the URL for this user's avatar.
+     * Auto-detects animated avatars (hash starting with `a_`) and uses gif extension.
+     * @param options - Optional `size` and `extension` (default: png, or gif for animated)
+     */
+    avatarURL(options?: {
+        size?: number;
+        extension?: string;
+    }): string | null;
+    /** Get the avatar URL, or the default avatar if none set (Fluxer: fluxerstatic.com). */
+    displayAvatarURL(options?: {
+        size?: number;
+        extension?: string;
+    }): string;
+    /**
+     * Get the URL for this user's banner.
+     * Returns null if the user has no banner (only available when fetched from profile/member context).
+     */
+    bannerURL(options?: {
+        size?: number;
+        extension?: string;
+    }): string | null;
+    /** Returns a mention string (e.g. `<@123456>`). */
+    toString(): string;
+    /**
+     * 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: MessageSendOptions): Promise<Message>;
+}
+
+/** 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;
+    /** Separately sorted position for hoisted roles. Null if not set. */
+    hoistPosition: number | null;
+    /** @param client - The client instance */
+    /** @param data - API role from GET /guilds/{id}/roles or gateway role events */
+    /** @param guildId - The guild this role belongs to */
+    constructor(client: Client, data: APIRole, guildId: string);
+    get permissions(): PermissionsBitField;
+    /** Update mutable fields from fresh API data. Used by edit and gateway events. */
+    _patch(data: Partial<APIRole>): void;
+    /** Returns a mention string (e.g. `<@&123456>`). */
+    toString(): string;
+    /**
+     * Edit this role.
+     * Requires Manage Roles permission.
+     * @param options - Role updates (permissions accepts PermissionResolvable for convenience)
+     * @returns This role (updated in place)
+     * @example
+     * await role.edit({ name: 'Moderator', permissions: ['BanMembers', 'KickMembers'] });
+     */
+    edit(options: RESTUpdateRoleBody & {
+        permissions?: string | PermissionResolvable;
+    }): Promise<Role>;
+    /**
+     * Delete this role.
+     * Requires Manage Roles permission.
+     */
+    delete(): Promise<void>;
+}
+
+/** Role ID or Role object for add/remove. */
+type RoleResolvable = string | Role;
+/**
+ * Manages a guild member's roles with add/remove/set and a cache of Role objects.
+ * Discord.js parity: member.roles.add(), member.roles.remove(), member.roles.set(), member.roles.cache
+ *
+ * @discordJsCompat https://discord.js.org/docs/packages/discord.js/main/GuildMemberRoleManager
+ * @example
+ * // Add a role (Discord.js style)
+ * await member.roles.add(roleId);
+ *
+ * @example
+ * // Remove a role
+ * await member.roles.remove(roleId);
+ *
+ * @example
+ * // Replace all roles
+ * await member.roles.set(['roleId1', 'roleId2']);
+ *
+ * @example
+ * // Check if member has a role
+ * if (member.roles.cache.has(roleId)) { ... }
+ */
+declare class GuildMemberRoleManager {
+    private readonly member;
+    private _roleIds;
+    constructor(member: GuildMember, initialRoleIds?: string[]);
+    /** Role IDs for this member. Used by permissions; prefer cache for Role objects. */
+    get roleIds(): readonly string[];
+    /** Check if the member has a role. Discord.js parity: member.roles.cache.has(roleId) */
+    has(roleOrId: RoleResolvable): boolean;
+    /**
+     * Collection of Role objects for this member's roles (from guild.roles).
+     * Discord.js parity: member.roles.cache
+     * @discordJsCompat https://discord.js.org/docs/packages/discord.js/main/GuildMemberRoleManager
+     */
+    get cache(): Collection<string, Role>;
+    /** Resolve role ID from RoleResolvable. */
+    private _resolveId;
+    /**
+     * Add a role to this member.
+     * Discord.js parity: member.roles.add(roleId)
+     * Requires Manage Roles permission.
+     * @discordJsCompat https://discord.js.org/docs/packages/discord.js/main/GuildMemberRoleManager
+     */
+    add(roleOrId: RoleResolvable): Promise<void>;
+    /**
+     * Remove a role from this member.
+     * Discord.js parity: member.roles.remove(roleId)
+     * Requires Manage Roles permission.
+     * @discordJsCompat https://discord.js.org/docs/packages/discord.js/main/GuildMemberRoleManager
+     */
+    remove(roleOrId: RoleResolvable): Promise<void>;
+    /**
+     * Replace all roles for this member. PATCH /guilds/{id}/members/{userId}
+     * Discord.js parity: member.roles.set(roleIds)
+     * Requires Manage Roles permission.
+     * @discordJsCompat https://discord.js.org/docs/packages/discord.js/main/GuildMemberRoleManager
+     */
+    set(roleIds: string[]): Promise<void>;
+    /**
+     * Update internal role IDs from API response. Called by GuildMember.edit().
+     * @internal
+     */
+    _patch(roleIds: string[]): void;
+}
+
+/** 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;
+    /**
+     * Role manager with add/remove/set and cache. Discord.js parity: member.roles.add(), member.roles.cache
+     * @discordJsCompat https://discord.js.org/docs/packages/discord.js/main/GuildMemberRoleManager
+     */
+    readonly roles: GuildMemberRoleManager;
+    readonly joinedAt: Date;
+    communicationDisabledUntil: Date | null;
+    readonly mute: boolean;
+    readonly deaf: boolean;
+    readonly avatar: string | null;
+    readonly banner: string | null;
+    readonly accentColor: number | null;
+    readonly profileFlags: number | null;
+    /** @param data - API guild member from GET /guilds/{id}/members or GET /guilds/{id}/members/{user_id} */
+    constructor(client: Client, data: APIGuildMember & {
+        guild_id?: string;
+    }, guild: Guild);
+    /** Nickname, or global name, or username. */
+    get displayName(): string;
+    /**
+     * Get the guild-specific avatar URL for this member.
+     * Returns null if the member has no guild avatar (use displayAvatarURL for fallback).
+     */
+    avatarURL(options?: {
+        size?: number;
+        extension?: string;
+    }): string | null;
+    /**
+     * Get the avatar URL to display for this member.
+     * Uses guild-specific avatar if set, otherwise falls back to the user's avatar.
+     */
+    displayAvatarURL(options?: {
+        size?: number;
+        extension?: string;
+    }): string;
+    /**
+     * Get the guild-specific banner URL for this member.
+     * Returns null if the member has no guild banner.
+     */
+    bannerURL(options?: {
+        size?: number;
+        extension?: string;
+    }): string | null;
+    /**
+     * Add a role to this member.
+     * Prefer member.roles.add(roleId) for Discord.js parity.
+     * @param roleId - The role ID to add
+     * Requires Manage Roles permission.
+     */
+    addRole(roleId: string): Promise<void>;
+    /**
+     * Remove a role from this member.
+     * Prefer member.roles.remove(roleId) for Discord.js parity.
+     * @param roleId - The role ID to remove
+     * Requires Manage Roles permission.
+     */
+    removeRole(roleId: string): Promise<void>;
+    /**
+     * Edit this guild member. PATCH /guilds/{id}/members/{userId} or /members/@me for the bot.
+     * For @me: nick, avatar, banner, bio, pronouns, accent_color, profile_flags, mute, deaf,
+     * communication_disabled_until, timeout_reason, channel_id, connection_id.
+     * For other members: same plus roles (array of role IDs).
+     */
+    edit(options: {
+        nick?: string | null;
+        roles?: string[];
+        avatar?: string | null;
+        banner?: string | null;
+        bio?: string | null;
+        pronouns?: string | null;
+        accent_color?: number | null;
+        profile_flags?: number | null;
+        mute?: boolean;
+        deaf?: boolean;
+        communication_disabled_until?: string | null;
+        timeout_reason?: string | null;
+        channel_id?: string | null;
+        connection_id?: string | null;
+    }): Promise<this>;
+    /**
+     * Get the member's guild-level permissions (from roles only, no channel overwrites).
+     * Use this for server-wide permission checks (e.g. ban, kick, manage roles).
+     * @returns Object with has(permission) to check specific permissions
+     * @example
+     * const perms = member.permissions;
+     * if (perms.has(PermissionFlags.BanMembers)) { ... }
+     */
+    get permissions(): BitField<"CreateInstantInvite" | "KickMembers" | "BanMembers" | "Administrator" | "ManageChannels" | "ManageGuild" | "AddReactions" | "ViewAuditLog" | "PrioritySpeaker" | "Stream" | "ViewChannel" | "SendMessages" | "SendTtsMessages" | "ManageMessages" | "EmbedLinks" | "AttachFiles" | "ReadMessageHistory" | "MentionEveryone" | "UseExternalEmojis" | "Connect" | "Speak" | "MuteMembers" | "DeafenMembers" | "MoveMembers" | "UseVad" | "ChangeNickname" | "ManageNicknames" | "ManageRoles" | "ManageWebhooks" | "ManageEmojisAndStickers" | "ManageExpressions" | "UseExternalStickers" | "ModerateMembers" | "CreateExpressions" | "PinMessages" | "BypassSlowmode" | "UpdateRtcRegion">;
+    /**
+     * Compute the member's effective permissions in a guild channel.
+     * Applies role permissions and channel overwrites.
+     * @param channel - The guild channel to check permissions for
+     * @returns Object with has(permission) to check specific permissions
+     * @example
+     * const perms = member.permissionsIn(channel);
+     * if (perms.has(PermissionFlags.SendMessages)) { ... }
+     */
+    permissionsIn(channel: GuildChannel): BitField<"CreateInstantInvite" | "KickMembers" | "BanMembers" | "Administrator" | "ManageChannels" | "ManageGuild" | "AddReactions" | "ViewAuditLog" | "PrioritySpeaker" | "Stream" | "ViewChannel" | "SendMessages" | "SendTtsMessages" | "ManageMessages" | "EmbedLinks" | "AttachFiles" | "ReadMessageHistory" | "MentionEveryone" | "UseExternalEmojis" | "Connect" | "Speak" | "MuteMembers" | "DeafenMembers" | "MoveMembers" | "UseVad" | "ChangeNickname" | "ManageNicknames" | "ManageRoles" | "ManageWebhooks" | "ManageEmojisAndStickers" | "ManageExpressions" | "UseExternalStickers" | "ModerateMembers" | "CreateExpressions" | "PinMessages" | "BypassSlowmode" | "UpdateRtcRegion">;
+    /**
+     * Move this member to a different voice channel or disconnect them from voice.
+     * Requires Move Members permission.
+     * @param channelId - The voice channel ID to move the member to, or null to disconnect
+     * @param connectionId - Optional connection ID for the specific voice session (usually not needed)
+     * @returns Promise that resolves when the member has been moved
+     * @example
+     * // Move member to a different voice channel
+     * await member.move('123456789012345678');
+     *
+     * // Disconnect member from voice
+     * await member.move(null);
+     */
+    move(channelId: string | null, connectionId?: string | null): Promise<void>;
+    private _computeBasePermissions;
+}
+
+/**
+ * Manages guild members with a Collection-like API.
+ * Extends Collection so you can use .get(), .set(), .filter(), etc.
+ * Provides guild.members.me for Discord.js parity.
+ *
+ * @discordJsCompat https://discord.js.org/docs/packages/discord.js/main/GuildMemberManager
+ */
+declare class GuildMemberManager extends Collection<string, GuildMember> {
+    private readonly guild;
+    constructor(guild: Guild);
+    /**
+     * Get a guild member from cache or fetch from the API if not present.
+     * Convenience helper to avoid repeating `guild.members.get(userId) ?? (await guild.fetchMember(userId))`.
+     * @param userId - Snowflake of the user
+     * @returns The guild member
+     * @throws FluxerError with MEMBER_NOT_FOUND if user is not in the guild (404)
+     * @example
+     * const member = await guild.members.resolve(userId);
+     * console.log(member.displayName);
+     */
+    resolve(userId: string): Promise<GuildMember>;
+    /**
+     * The current bot user as a GuildMember in this guild.
+     * Returns null if the bot's member is not cached or client.user is null.
+     * Use fetchMe() to load the bot's member when not cached.
+     *
+     * @discordJsCompat https://discord.js.org/docs/packages/discord.js/main/GuildMemberManager
+     * @example
+     * const perms = guild.members.me?.permissions;
+     * if (perms?.has(PermissionFlags.BanMembers)) { ... }
+     */
+    get me(): GuildMember | null;
+    /**
+     * Fetch the current bot user as a GuildMember in this guild.
+     * Caches the result in guild.members.
+     *
+     * @throws Error if client.user is null (client not ready)
+     * @example
+     * const me = await guild.members.fetchMe();
+     * console.log(me.displayName);
+     */
+    fetchMe(): Promise<GuildMember>;
+    /**
+     * Fetch guild members with pagination. GET /guilds/{id}/members.
+     * @param options - limit (1-1000), after (user ID for pagination)
+     * @returns Array of GuildMember objects (cached in guild.members)
+     */
+    fetch(options?: {
+        limit?: number;
+        after?: string;
+    }): Promise<GuildMember[]>;
+}
+
+/** File data for webhook attachment uploads. Use `data` for buffers or `url` to fetch from a URL. */
+type WebhookFileData = MessageFileData;
+/** Attachment metadata for webhook file uploads (id matches FormData index). */
+interface WebhookAttachmentMeta {
+    id: number;
+    filename: string;
+    title?: string | null;
+    description?: string | null;
+    /** MessageAttachmentFlags: IS_SPOILER (8), CONTAINS_EXPLICIT_MEDIA (16), IS_ANIMATED (32) */
+    flags?: number;
+}
+/** Options for sending a message via webhook. Aligns with WebhookMessageRequest in the API. */
+interface WebhookSendOptions {
+    /** Message text content (up to 2000 characters) */
+    content?: string;
+    /** Embed objects. Use EmbedBuilder or APIEmbed; EmbedBuilder is serialized automatically. */
+    embeds?: (APIEmbed | EmbedBuilder)[];
+    /** Override the webhook's default username for this message */
+    username?: string;
+    /** Override the webhook's default avatar URL for this message */
+    avatar_url?: string;
+    /** Text-to-speech */
+    tts?: boolean;
+    /** File attachments. When present, uses multipart/form-data (same as channel.send). */
+    files?: WebhookFileData[];
+    /** Attachment metadata for files (id = index). Use when files are provided. */
+    attachments?: WebhookAttachmentMeta[];
+}
+/**
+ * Represents a Discord/Fluxer webhook. Supports creating, fetching, sending, and deleting.
+ * The token is only available when the webhook was created; fetched webhooks cannot send messages.
+ */
+declare class Webhook extends Base {
+    readonly client: Client;
+    readonly id: string;
+    readonly guildId: string;
+    channelId: string;
+    name: string;
+    avatar: string | null;
+    /** Present only when webhook was created via createWebhook(); not returned when fetching. */
+    readonly token: string | null;
+    /** User who created the webhook. */
+    readonly user: User;
+    /** @param data - API webhook from POST /channels/{id}/webhooks (has token) or GET /webhooks/{id} (no token) */
+    constructor(client: Client, data: APIWebhook & {
+        token?: string | null;
+    });
+    /**
+     * Get the URL for this webhook's avatar.
+     * Returns null if the webhook has no custom avatar.
+     */
+    avatarURL(options?: {
+        size?: number;
+        extension?: string;
+    }): string | null;
+    /** Delete this webhook. Requires bot token with Manage Webhooks permission. */
+    delete(): Promise<void>;
+    /**
+     * Edit this webhook. With token: name and avatar only. Without token (bot auth): name, avatar, and channel_id.
+     * @param options - Fields to update (name, avatar, channel_id when using bot auth)
+     * @returns This webhook instance with updated fields
+     */
+    edit(options: APIWebhookUpdateRequest | APIWebhookTokenUpdateRequest): Promise<Webhook>;
+    /**
+     * Send a message via this webhook. Requires the webhook token (only present when created, not when fetched).
+     * @param options - Text content or object with content, embeds, username, avatar_url, tts, files, attachments
+     * @param wait - If true, waits for the API and returns the created Message; otherwise returns void (204)
+     * @throws Error if token is not available
+     * @example
+     * await webhook.send('Hello!');
+     * await webhook.send({ embeds: [embed] });
+     * await webhook.send({ content: 'File attached', files: [{ name: 'data.txt', data: buffer }] });
+     * const msg = await webhook.send({ content: 'Hi' }, true);
+     */
+    send(options: string | WebhookSendOptions, wait?: boolean): Promise<Message | undefined>;
+    /**
+     * Edit a message previously sent by this webhook.
+     * Requires the webhook token.
+     * @param messageId - The ID of the message to edit
+     * @param options - Fields to update (content, embeds, attachments)
+     * @returns The updated Message
+     * @throws Error if token is not available
+     */
+    editMessage(messageId: string, options: APIWebhookEditMessageRequest): Promise<Message>;
+    /**
+     * Fetch a message sent by this webhook.
+     * Requires the webhook token.
+     * @param messageId - The ID of the message to fetch
+     * @returns The message
+     * @throws Error if token is not available
+     */
+    fetchMessage(messageId: string): Promise<Message>;
+    /**
+     * Delete a message sent by this webhook.
+     * Requires the webhook token.
+     * @param messageId - The ID of the message to delete
+     * @throws Error if token is not available
+     */
+    deleteMessage(messageId: string): Promise<void>;
+    /**
+     * 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).
+     * @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;
+        guildId?: string;
+        name?: string;
+    }): Webhook;
+}
+
+/** Represents a ban in a guild. */
+declare class GuildBan extends Base {
+    readonly client: Client;
+    readonly guildId: string;
+    readonly user: User;
+    readonly reason: string | null;
+    /** ISO timestamp when a temporary ban expires. Null for permanent bans. */
+    readonly expiresAt: string | null;
+    /** @param data - API ban from GET /guilds/{id}/bans or gateway GUILD_BAN_ADD */
+    constructor(client: Client, data: APIBan & {
+        guild_id?: string;
+    }, guildId: string);
+    /**
+     * Remove this ban (unban the user).
+     * Requires Ban Members permission.
+     */
+    unban(): Promise<void>;
+}
+
+/** Represents a 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>;
+}
+
+/** Represents an invite to a guild or channel. */
+declare class Invite extends Base {
+    readonly client: Client;
+    readonly code: string;
+    readonly type: number;
+    readonly guild: APIGuildPartial;
+    readonly channel: APIChannelPartial;
+    readonly inviter: User | null;
+    readonly memberCount: number | null;
+    readonly presenceCount: number | null;
+    readonly expiresAt: string | null;
+    readonly temporary: boolean | null;
+    readonly createdAt: string | null;
+    readonly uses: number | null;
+    readonly maxUses: number | null;
+    readonly maxAge: number | null;
+    /**
+     * Normalize an invite input into a raw invite code.
+     * Accepts either an invite code (e.g. "abc123") or a URL (e.g. "https://fluxer.gg/abc123").
+     */
+    private static normalizeCode;
+    /** @param data - API invite from GET /invites/{code}, channel/guild invite list, or gateway INVITE_CREATE */
+    constructor(client: Client, data: APIInvite);
+    /**
+     * Fetch invite information by code or URL.
+     * Does not consume or accept the invite.
+     */
+    static fetch(client: Client, codeOrUrl: string): Promise<Invite>;
+    /** 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 Fluxer guild (server). */
+declare class Guild extends Base {
+    readonly client: Client;
+    readonly id: string;
+    name: string;
+    icon: string | null;
+    banner: string | null;
+    readonly ownerId: string;
+    /** Invite splash image hash. Null if none. */
+    splash: string | null;
+    /** Custom vanity URL code (e.g. fluxer.gg/code). Null if none. */
+    vanityURLCode: string | null;
+    /** Enabled guild features. */
+    features: GuildFeature[];
+    verificationLevel: GuildVerificationLevel;
+    defaultMessageNotifications: DefaultMessageNotifications;
+    explicitContentFilter: GuildExplicitContentFilter;
+    /** AFK voice channel ID. Null if none. */
+    afkChannelId: string | null;
+    /** AFK timeout in seconds. */
+    afkTimeout: number;
+    /** System messages channel ID. Null if none. */
+    systemChannelId: string | null;
+    /** Rules/guidelines channel ID. Null if none. */
+    rulesChannelId: string | null;
+    nsfwLevel: number;
+    mfaLevel: GuildMFALevel;
+    /** Banner image width. Optional. */
+    bannerWidth?: number | null;
+    /** Banner image height. Optional. */
+    bannerHeight?: number | null;
+    /** Splash image width. Optional. */
+    splashWidth?: number | null;
+    /** Splash image height. Optional. */
+    splashHeight?: number | null;
+    members: GuildMemberManager;
+    channels: Collection<string, GuildChannel>;
+    roles: Collection<string, Role>;
+    emojis: Collection<string, GuildEmoji>;
+    stickers: Collection<string, GuildSticker>;
+    /** @param data - API guild from GET /guilds/{id} or gateway GUILD_CREATE */
+    constructor(client: Client, data: APIGuild & {
+        roles?: APIRole[];
+        ownerId?: string;
+    });
+    /** Get the guild icon URL, or null if no icon. */
+    iconURL(options?: {
+        size?: number;
+    }): string | null;
+    /** Get the guild banner URL, or null if no banner. */
+    bannerURL(options?: {
+        size?: number;
+    }): string | null;
+    /** Get the guild splash (invite background) URL, or null if no splash. */
+    splashURL(options?: {
+        size?: number;
+    }): string | null;
+    /**
+     * Add a role to a member by user ID. Does not require fetching the member first.
+     * @param userId - The user ID of the member
+     * @param roleId - The role ID to add (or use guild.resolveRoleId for mention/name resolution)
+     * Requires Manage Roles permission.
+     */
+    addRoleToMember(userId: string, roleId: string): Promise<void>;
+    /**
+     * Remove a role from a member by user ID. Does not require fetching the member first.
+     * @param userId - The user ID of the member
+     * @param roleId - The role ID to remove
+     * Requires Manage Roles permission.
+     */
+    removeRoleFromMember(userId: string, roleId: string): Promise<void>;
+    /**
+     * Create a role in this guild.
+     * Requires Manage Roles permission.
+     * @param options - Role data (permissions accepts PermissionResolvable for convenience)
+     * @returns The created role
+     * @example
+     * const role = await guild.createRole({ name: 'Mod', permissions: ['KickMembers', 'BanMembers'] });
+     */
+    createRole(options: RESTCreateRoleBody & {
+        permissions?: string | PermissionResolvable;
+    }): Promise<Role>;
+    /**
+     * Fetch all roles in this guild.
+     * @returns Array of Role objects (cached in guild.roles)
+     */
+    fetchRoles(): Promise<Role[]>;
+    /**
+     * Fetch a role by ID.
+     * @param roleId - The role ID to fetch
+     * @returns The role
+     * @throws FluxerError with ROLE_NOT_FOUND if role does not exist (404)
+     */
+    fetchRole(roleId: string): Promise<Role>;
+    /**
+     * Resolve a role ID from an argument (role mention, raw ID, or name).
+     * Fetches guild roles if name is provided.
+     * @param arg - Role mention (@role), role ID, or role name
+     * @returns The role ID, or null if not found
+     */
+    resolveRoleId(arg: string): Promise<string | null>;
+    /**
+     * Ban a user from this guild.
+     * @param userId - The user ID to ban
+     * @param options - Optional reason, delete_message_days (0–7), and ban_duration_seconds (temporary ban).
+     *   ban_duration_seconds: 0 = permanent, or use 3600, 43200, 86400, 259200, 432000, 604800, 1209600, 2592000.
+     * Requires Ban Members permission.
+     */
+    ban(userId: string, options?: {
+        reason?: string;
+        delete_message_days?: number;
+        ban_duration_seconds?: number;
+    }): Promise<void>;
+    /**
+     * Fetch guild bans. Requires Ban Members permission.
+     * @returns List of GuildBan objects
+     */
+    fetchBans(): Promise<GuildBan[]>;
+    /**
+     * Remove a ban (unban a user).
+     * @param userId - The user ID to unban
+     * Requires Ban Members permission.
+     */
+    unban(userId: string): Promise<void>;
+    /**
+     * Kick a member from this guild.
+     * @param userId - The user ID to kick
+     * Requires Kick Members permission.
+     */
+    kick(userId: string): Promise<void>;
+    /**
+     * Fetch a guild member by user ID.
+     * @param userId - The user ID of the member to fetch
+     * @returns The guild member
+     * @throws FluxerError with MEMBER_NOT_FOUND if user is not in the guild (404)
+     * @throws FluxerError with cause for permission denied (403) or other REST errors
+     */
+    fetchMember(userId: string): Promise<GuildMember>;
+    /**
+     * Fetch guild audit logs. Requires View Audit Log permission.
+     * @param options - Optional limit, before, after, user_id, action_type for filtering
+     */
+    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[]>;
+    /**
+     * Fetch all invites in this guild.
+     * Requires Manage Guild permission.
+     */
+    fetchInvites(): Promise<Invite[]>;
+    /**
+     * Fetch a guild invite by code or URL.
+     * Convenience wrapper for Invite.fetch(client, codeOrUrl).
+     */
+    fetchInvite(codeOrUrl: string): Promise<Invite>;
+    /**
+     * Create a channel in this guild.
+     * @param data - Channel data: type (0=text, 2=voice, 4=category, 5=link), name, and optional parent_id, topic, bitrate, user_limit, nsfw, permission_overwrites
+     * Requires Manage Channels permission.
+     */
+    createChannel(data: {
+        type: 0 | 2 | 4 | 5;
+        name: string;
+        parent_id?: string | null;
+        topic?: string | null;
+        bitrate?: number | null;
+        user_limit?: number | null;
+        nsfw?: boolean;
+        permission_overwrites?: Array<{
+            id: string;
+            type: number;
+            allow: string;
+            deny: string;
+        }>;
+    }): Promise<GuildChannel>;
+    /**
+     * Fetch all channels in this guild.
+     * @returns Array of GuildChannel objects (cached in guild.channels and client.channels)
+     */
+    fetchChannels(): Promise<GuildChannel[]>;
+    /**
+     * Edit this guild. PATCH /guilds/{id}.
+     * Requires guild owner or Administrator.
+     */
+    edit(options: {
+        name?: string;
+        icon?: string | null;
+        system_channel_id?: string | null;
+        system_channel_flags?: number;
+        afk_channel_id?: string | null;
+        afk_timeout?: number;
+        default_message_notifications?: DefaultMessageNotifications;
+        verification_level?: GuildVerificationLevel;
+        mfa_level?: GuildMFALevel;
+        explicit_content_filter?: GuildExplicitContentFilter;
+        banner?: string | null;
+        splash?: string | null;
+        embed_splash?: string | null;
+        splash_card_alignment?: string;
+        features?: GuildFeature[];
+    }): Promise<this>;
+    /**
+     * Delete this guild. POST /guilds/{id}/delete.
+     * Must be the guild owner.
+     */
+    delete(): Promise<void>;
+    /**
+     * Fetch vanity URL for this guild. GET /guilds/{id}/vanity-url.
+     * Requires Manage Guild permission.
+     */
+    fetchVanityURL(): Promise<APIVanityURL>;
+    /**
+     * Transfer guild ownership to another user. POST /guilds/{id}/transfer-ownership.
+     * Must be the guild owner.
+     */
+    transferOwnership(newOwnerId: string, password?: string): Promise<void>;
+    /**
+     * Set text channel flexible names feature. PATCH /guilds/{id}/text-channel-flexible-names.
+     */
+    setTextChannelFlexibleNames(enabled: boolean): Promise<this>;
+    /**
+     * Set detached banner feature. PATCH /guilds/{id}/detached-banner.
+     */
+    setDetachedBanner(enabled: boolean): Promise<this>;
+    /**
+     * Set disallow unclaimed accounts. PATCH /guilds/{id}/disallow-unclaimed-accounts.
+     */
+    setDisallowUnclaimedAccounts(enabled: boolean): Promise<this>;
+    /**
+     * Update role positions. PATCH /guilds/{id}/roles.
+     * @param updates - Array of { id, position? }
+     */
+    setRolePositions(updates: Array<{
+        id: string;
+        position?: number;
+    }>): Promise<APIRole[]>;
+    /**
+     * Update role hoist positions. PATCH /guilds/{id}/roles/hoist-positions.
+     */
+    setRoleHoistPositions(updates: Array<{
+        id: string;
+        hoist_position?: number;
+    }>): Promise<APIRole[]>;
+    /**
+     * Reset role hoist positions. DELETE /guilds/{id}/roles/hoist-positions.
+     */
+    resetRoleHoistPositions(): Promise<APIRole[]>;
+    /**
+     * Update channel positions.
+     * @param updates - Array of { id, position?, parent_id?, lock_permissions? }
+     * Requires Manage Channels permission.
+     */
+    setChannelPositions(updates: Array<{
+        id: string;
+        position?: number;
+        parent_id?: string | null;
+        lock_permissions?: boolean;
+    }>): Promise<void>;
+    /**
+     * Fetch all emojis in this guild.
+     * @returns Array of GuildEmoji objects (cached in guild.emojis)
+     */
+    fetchEmojis(): Promise<GuildEmoji[]>;
+    /**
+     * Fetch a single emoji by ID.
+     * @param emojiId - The emoji ID to fetch
+     * @returns The guild emoji
+     * @throws FluxerError if emoji not found (404)
+     */
+    fetchEmoji(emojiId: string): Promise<GuildEmoji>;
+    /**
+     * Fetch all stickers in this guild.
+     * @returns Array of GuildSticker objects (cached in guild.stickers)
+     */
+    fetchStickers(): Promise<GuildSticker[]>;
+    /**
+     * Fetch a single sticker by ID.
+     * @param stickerId - The sticker ID to fetch
+     */
+    fetchSticker(stickerId: string): Promise<GuildSticker>;
+    /**
+     * Bulk create emojis. POST /guilds/{id}/emojis/bulk.
+     * @param emojis - Array of { name, image } (base64), 1-50 emojis
+     * @returns Array of created GuildEmoji objects
+     */
+    createEmojisBulk(emojis: Array<{
+        name: string;
+        image: string;
+    }>): Promise<GuildEmoji[]>;
+    /**
+     * Bulk create stickers. POST /guilds/{id}/stickers/bulk.
+     * @param stickers - Array of { name, image, description?, tags? }, 1-50 stickers
+     * @returns Array of created GuildSticker objects
+     */
+    createStickersBulk(stickers: Array<{
+        name: string;
+        image: string;
+        description?: string;
+        tags?: string[];
+    }>): Promise<GuildSticker[]>;
+}
+
+/** 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.
+     * @throws FluxerError with MESSAGE_NOT_FOUND if the message does not exist
+     */
+    fetchMessage(): Promise<Message>;
+}
+
+interface ReactionCollectorOptions {
+    /** Filter function. Return true to collect the reaction. */
+    filter?: (reaction: MessageReaction, user: User) => boolean;
+    /** Max duration in ms. Collector stops when time expires. */
+    time?: number;
+    /** Max reactions to collect. Collector stops when limit reached. */
+    max?: number;
+}
+type ReactionCollectorEndReason = 'time' | 'limit' | 'user';
+interface CollectedReaction {
+    reaction: MessageReaction;
+    user: User;
+}
+interface ReactionCollectorEvents {
+    collect: [reaction: MessageReaction, user: User];
+    end: [collected: Collection<string, CollectedReaction>, reason: ReactionCollectorEndReason];
+}
+/**
+ * Collects reactions on a message. Use message.createReactionCollector().
+ * @example
+ * const collector = message.createReactionCollector({ filter: (r, u) => u.id === userId, time: 10000 });
+ * collector.on('collect', (reaction, user) => console.log(user.username, 'reacted', reaction.emoji.name));
+ * collector.on('end', (collected, reason) => console.log(`Stopped: ${reason}`));
+ */
+declare class ReactionCollector extends EventEmitter {
+    readonly client: Client;
+    readonly messageId: string;
+    readonly channelId: string;
+    readonly options: Required<ReactionCollectorOptions>;
+    readonly collected: Collection<string, CollectedReaction>;
+    private _timeout;
+    private _ended;
+    private _listener;
+    constructor(client: Client, messageId: string, channelId: string, options?: ReactionCollectorOptions);
+    stop(reason?: ReactionCollectorEndReason): void;
+    on<K extends keyof ReactionCollectorEvents>(event: K, listener: (...args: ReactionCollectorEvents[K]) => void): this;
+    emit<K extends keyof ReactionCollectorEvents>(event: K, ...args: ReactionCollectorEvents[K]): boolean;
+}
+
+/** Options for editing a message (content and/or embeds). */
+interface MessageEditOptions {
+    /** New text content */
+    content?: string;
+    /** New embeds (replaces existing) */
+    embeds?: (APIEmbed | EmbedBuilder)[];
+}
+type MessagePayload = {
+    files?: ResolvedMessageFile[];
+    body: SendBodyResult & {
+        message_reference?: APIMessageReference;
+        flags?: number;
+    };
+};
+/** Options for message.reply() — ping toggle and reply-to-different-message. */
+interface ReplyOptions {
+    /** Whether to ping the replied-to user (default true). Use false to suppress the mention notification. */
+    ping?: boolean;
+    /** Reply to a different message instead of this one. Default: this message. */
+    replyTo?: Message | {
+        channelId: string;
+        messageId: string;
+    };
+}
+
+/** 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>;
+    readonly type: MessageType;
+    readonly flags: number;
+    readonly mentionEveryone: boolean;
+    readonly tts: boolean;
+    readonly embeds: APIEmbed[];
+    readonly stickers: APIMessageSticker[];
+    readonly reactions: APIMessageReaction[];
+    readonly messageReference: APIMessageReference | null;
+    readonly messageSnapshots: APIMessageSnapshot[];
+    readonly call: APIMessageCall | null;
+    readonly referencedMessage: Message | null;
+    /** Webhook ID if this message was sent via webhook. Null otherwise. */
+    readonly webhookId: string | null;
+    /** Users mentioned in this message. */
+    readonly mentions: User[];
+    /** Role IDs mentioned in this message. */
+    readonly mentionRoles: string[];
+    /** Client-side nonce for acknowledgment. Null if not provided. */
+    readonly nonce: string | null;
+    /**
+     * Channel where this message was sent. Resolved from cache; null if not cached.
+     * Messages can only exist in text-based channels (text, DM, announcement), so this always has send() when non-null.
+     */
+    get channel(): (TextChannel | DMChannel | GuildChannel) | null;
+    /** Guild where this message was sent. Resolved from cache; null for DMs or if not cached. */
+    get guild(): Guild | null;
+    /**
+     * Resolve the channel (from cache or API). Use when you need the channel and it may not be cached.
+     * @returns The channel
+     * @throws FluxerError with CHANNEL_NOT_FOUND if the channel does not exist
+     */
+    resolveChannel(): Promise<Channel>;
+    /**
+     * Resolve the guild (from cache or API). Returns null for DMs.
+     * @returns The guild, or null if this is a DM or guild not found
+     */
+    resolveGuild(): Promise<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, embeds, and/or files
+     * @example
+     * await message.send('Pong!');
+     * await message.send({ embeds: [embed] }); // EmbedBuilder auto-converted
+     * await message.send({ content: 'File', files: [{ name: 'data.txt', data }] });
+     */
+    send(options: string | MessageSendOptions): Promise<Message>;
+    /**
+     * Send a message to a specific channel. Use for logging, forwarding, or sending to another channel in the guild.
+     * @param channelId - Snowflake of the target channel (e.g. log channel ID)
+     * @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] });
+     */
+    sendTo(channelId: string, options: MessageSendOptions): Promise<Message>;
+    /**
+     * Reply to this message (shows as a reply in the client).
+     * @param options - Text content or object with content, embeds, and/or reply options (ping, replyTo)
+     * @example
+     * await message.reply('Pong!');
+     * await message.reply({ embeds: [embed] });
+     * await message.reply('No ping!', { ping: false });
+     * await message.reply({ content: 'Reply to other', replyTo: otherMessage });
+     */
+    reply(options: string | (MessageSendOptions & ReplyOptions), replyOptions?: ReplyOptions): Promise<Message>;
+    /** Exposed for testing purposes, use Message.reply() or send() for normal use */
+    static _createMessageBody(content: string | MessageSendOptions, referenced_message?: {
+        channel_id: string;
+        message_id: string;
+        guild_id?: string;
+    }, ping?: boolean): Promise<MessagePayload>;
+    _send(payload: MessagePayload): Promise<Message>;
+    /**
+     * Edit this message. Only the author (or admins) can edit.
+     * @param options - New content and/or embeds
+     */
+    edit(options: MessageEditOptions): Promise<Message>;
+    /**
+     * Create a reaction collector for this message.
+     * Collects reactions matching the filter until time expires or max is reached.
+     * @param options - Filter, time (ms), and max count
+     * @example
+     * const collector = message.createReactionCollector({ filter: (r, u) => u.id === userId, time: 10000 });
+     * collector.on('collect', (reaction, user) => console.log(user.username, 'reacted with', reaction.emoji.name));
+     * collector.on('end', (collected, reason) => { ... });
+     */
+    createReactionCollector(options?: ReactionCollectorOptions): ReactionCollector;
+    /**
+     * Re-fetch this message from the API to get the latest content, embeds, reactions, etc.
+     * Use when you have a stale Message (e.g. from an old event or cache) and need fresh data.
+     * @returns The updated message
+     * @throws FluxerError with MESSAGE_NOT_FOUND if the message was deleted or does not exist
+     * @example
+     * const updated = await message.fetch();
+     * console.log('Latest content:', updated.content);
+     */
+    fetch(): Promise<Message>;
+    /** Delete this message. */
+    delete(): Promise<void>;
+    /**
+     * Delete a specific attachment from this message.
+     * DELETE /channels/{id}/messages/{id}/attachments/{attachmentId}.
+     */
+    deleteAttachment(attachmentId: string): Promise<void>;
+    /** Pin this message to the channel. Requires Manage Messages permission. */
+    pin(): Promise<void>;
+    /** Unpin this message from the channel. Requires Manage Messages permission. */
+    unpin(): Promise<void>;
+    /**
+     * Format emoji for reaction API: unicode string or "name:id" for custom.
+     * For string resolution (e.g. :name:), use client.resolveEmoji; Message methods resolve automatically when guildId is available.
+     */
+    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>;
+    /**
+     * Fetch users who reacted with the given emoji.
+     * @param emoji - Unicode emoji or custom `{ name, id }`
+     * @param options - limit (1–100), after (user ID for pagination)
+     * @returns Array of User objects
+     */
+    fetchReactionUsers(emoji: string | {
+        name: string;
+        id?: string;
+        animated?: boolean;
+    }, options?: {
+        limit?: number;
+        after?: string;
+    }): Promise<User[]>;
+}
+
+/**
+ * Manages messages for a channel. Access via channel.messages.
+ * @example
+ * const message = channel.messages.get(messageId);  // from cache (if enabled)
+ * const message = await channel.messages.fetch(messageId);  // from API
+ * if (message) await message.edit({ content: 'Updated!' });
+ */
+declare class MessageManager {
+    private readonly client;
+    private readonly channelId;
+    constructor(client: Client, channelId: string);
+    /**
+     * Get a message from cache. Returns undefined if not cached or caching is disabled.
+     * Requires options.cache.messages > 0.
+     * @param messageId - Snowflake of the message
+     */
+    get(messageId: string): Message | undefined;
+    /**
+     * Fetch a message by ID from this channel.
+     * When message caching is enabled, the fetched message is added to the cache.
+     * @param messageId - Snowflake of the message
+     * @returns The message
+     * @throws FluxerError with MESSAGE_NOT_FOUND if the message does not exist
+     */
+    fetch(messageId: string): Promise<Message>;
+}
+
+interface MessageCollectorOptions {
+    /** Filter function. Return true to collect the message. */
+    filter?: (message: Message) => boolean;
+    /** Max duration in ms. Collector stops when time expires. */
+    time?: number;
+    /** Max messages to collect. Collector stops when limit reached. */
+    max?: number;
+}
+type MessageCollectorEndReason = 'time' | 'limit' | 'user';
+interface MessageCollectorEvents {
+    collect: [message: Message];
+    end: [collected: Collection<string, Message>, reason: MessageCollectorEndReason];
+}
+/**
+ * Collects messages in a channel. Use channel.createMessageCollector().
+ * @example
+ * const collector = channel.createMessageCollector({ filter: m => m.author.id === userId, time: 10000 });
+ * collector.on('collect', m => console.log(m.content));
+ * collector.on('end', (collected, reason) => console.log(`Stopped: ${reason}`));
+ */
+declare class MessageCollector extends EventEmitter {
+    readonly client: Client;
+    readonly channelId: string;
+    readonly options: Required<MessageCollectorOptions>;
+    readonly collected: Collection<string, Message>;
+    private _timeout;
+    private _ended;
+    private _listener;
+    constructor(client: Client, channelId: string, options?: MessageCollectorOptions);
+    stop(reason?: MessageCollectorEndReason): void;
+    on<K extends keyof MessageCollectorEvents>(event: K, listener: (...args: MessageCollectorEvents[K]) => void): this;
+    emit<K extends keyof MessageCollectorEvents>(event: K, ...args: MessageCollectorEvents[K]): boolean;
+}
+
+/** Base class for all channel types. */
+declare abstract class Channel extends Base {
+    /** Whether this channel has a send method (TextChannel, DMChannel). */
+    isTextBased(): this is TextChannel | DMChannel;
+    /** Whether this channel is a DM or Group DM. */
+    isDM(): this is DMChannel;
+    /** Whether this channel is voice-based (VoiceChannel). */
+    isVoice(): this is VoiceChannel;
+    isLink(): this is LinkChannel;
+    /** 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;
+    /** Channel name. Guild channels and Group DMs have names; 1:1 DMs are typically null. */
+    name: string | null;
+    /** Channel icon hash (Group DMs). Null if none. */
+    icon: string | null;
+    /** ISO timestamp when the last message was pinned. Null if never pinned. */
+    lastPinTimestamp: string | null;
+    /** @param data - API channel from GET /channels/{id} or GET /guilds/{id}/channels */
+    constructor(client: Client, data: APIChannelPartial);
+    /**
+     * 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;
+    /**
+     * Bulk delete messages. Requires Manage Messages permission.
+     * @param messageIds - Array of message IDs to delete (2–100)
+     */
+    bulkDeleteMessages(messageIds: string[]): Promise<void>;
+    /**
+     * Send a typing indicator to the channel. Lasts ~10 seconds.
+     */
+    sendTyping(): Promise<void>;
+    /**
+     * Whether the bot can send messages in this channel.
+     * For DMs: always true (when the channel exists).
+     * For guild channels: checks ViewChannel and SendMessages permissions via guild.members.me.
+     */
+    canSendMessage(): boolean;
+}
+declare class GuildChannel extends Channel {
+    readonly guildId: string;
+    name: string | null;
+    position?: number;
+    parentId: string | null;
+    /** Permission overwrites for roles and members. */
+    permissionOverwrites: APIChannelOverwrite[];
+    constructor(client: Client, data: APIChannel);
+    /**
+     * Create a webhook in this channel.
+     * @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.
+     * @returns Webhooks (includes token when listing from channel; can send via send())
+     */
+    fetchWebhooks(): Promise<Webhook[]>;
+    /**
+     * Create an invite for this channel.
+     * @param options - max_uses (0–100), max_age (0–604800 seconds), unique, temporary
+     * Requires Create Instant Invite permission.
+     */
+    createInvite(options?: {
+        max_uses?: number;
+        max_age?: number;
+        unique?: boolean;
+        temporary?: boolean;
+    }): Promise<Invite>;
+    /**
+     * Fetch invites for this channel.
+     * Requires Manage Channel permission.
+     */
+    fetchInvites(): Promise<Invite[]>;
+    /**
+     * Set or update a permission overwrite. PUT /channels/{id}/permissions/{overwriteId}.
+     * @param overwriteId - Role or member ID
+     * @param options - type (0=role, 1=member), allow, deny (permission bitfields)
+     */
+    editPermission(overwriteId: string, options: {
+        type: 0 | 1;
+        allow?: string;
+        deny?: string;
+    }): Promise<void>;
+    /**
+     * Whether the bot can send messages in this channel.
+     * Checks ViewChannel and SendMessages via guild.members.me permissions.
+     * Returns false if guild or bot member not cached.
+     */
+    canSendMessage(): boolean;
+    /**
+     * Send a message to this guild channel.
+     * Works for text and announcement channels. Voice/category/link channels will fail at the API.
+     */
+    send(options: MessageSendOptions): Promise<Message>;
+    /**
+     * Remove a permission overwrite. DELETE /channels/{id}/permissions/{overwriteId}.
+     */
+    deletePermission(overwriteId: string): Promise<void>;
+    /**
+     * Edit this channel. PATCH /channels/{id}.
+     * Requires Manage Channel permission.
+     */
+    edit(options: {
+        name?: string | null;
+        topic?: string | null;
+        parent_id?: string | null;
+        bitrate?: number | null;
+        user_limit?: number | null;
+        nsfw?: boolean;
+        rate_limit_per_user?: number;
+        rtc_region?: string | null;
+        permission_overwrites?: Array<{
+            id: string;
+            type: number;
+            allow?: string;
+            deny?: string;
+        }>;
+    }): Promise<this>;
+    /**
+     * Delete this channel. Requires Manage Channel permission.
+     * @param options - silent: if true, does not send a system message (default false)
+     */
+    delete(options?: {
+        silent?: boolean;
+    }): Promise<void>;
+}
+declare class TextChannel extends GuildChannel {
+    topic?: string | null;
+    nsfw?: boolean;
+    rateLimitPerUser?: number;
+    lastMessageId?: string | null;
+    constructor(client: Client, data: APIChannel);
+    /**
+     * Send a message to this channel.
+     * @param options - Text content or object with content, embeds, and/or files
+     */
+    send(options: MessageSendOptions): Promise<Message>;
+    /** Message manager for this channel. Use channel.messages.fetch(messageId). */
+    get messages(): MessageManager;
+    /**
+     * Create a message collector for this channel.
+     * Collects messages matching the filter until time expires or max is reached.
+     * @param options - Filter, time (ms), and max count
+     * @example
+     * const collector = channel.createMessageCollector({ filter: m => m.author.id === userId, time: 10000 });
+     * collector.on('collect', m => console.log(m.content));
+     * collector.on('end', (collected, reason) => { ... });
+     */
+    createMessageCollector(options?: MessageCollectorOptions): MessageCollector;
+    /**
+     * Fetch pinned messages in this channel.
+     * @returns Pinned messages
+     */
+    fetchPinnedMessages(): Promise<Message[]>;
+    /**
+     * Fetch a message by ID from this channel.
+     * @param messageId - Snowflake of the message
+     * @returns The message, or null if not found
+     * @deprecated Use channel.messages.fetch(messageId) instead.
+     */
+    fetchMessage(messageId: string): Promise<Message>;
+}
+declare class CategoryChannel extends GuildChannel {
+}
+declare class VoiceChannel extends GuildChannel {
+    bitrate?: number | null;
+    userLimit?: number | null;
+    rtcRegion?: string | null;
+    constructor(client: Client, data: APIChannel);
+}
+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;
+    /** Group DM creator ID. Null for 1:1 DMs. */
+    ownerId: string | null;
+    /** Group DM recipients as User objects. Empty for 1:1 DMs. */
+    recipients: User[];
+    /** Group DM member display names (userId -> nickname). */
+    nicks: Record<string, string>;
+    constructor(client: Client, data: APIChannelPartial & Partial<APIChannel>);
+    /**
+     * Send a message to this DM channel.
+     * @param options - Text content or object with content, embeds, and/or files
+     */
+    send(options: MessageSendOptions): Promise<Message>;
+    /** Message manager for this channel. Use channel.messages.fetch(messageId). */
+    get messages(): MessageManager;
+    /**
+     * Create a message collector for this DM channel.
+     * @param options - Filter, time (ms), and max count
+     */
+    createMessageCollector(options?: MessageCollectorOptions): MessageCollector;
+    /**
+     * Fetch pinned messages in this DM channel.
+     * @returns Pinned messages
+     */
+    fetchPinnedMessages(): Promise<Message[]>;
+    /**
+     * Fetch a message by ID from this DM channel.
+     * @param messageId - Snowflake of the message
+     * @returns The message, or null if not found
+     * @deprecated Use channel.messages.fetch(messageId) instead.
+     */
+    fetchMessage(messageId: string): Promise<Message>;
+    /**
+     * Add a recipient to this Group DM. Requires Group DM (type GroupDM).
+     * PUT /channels/{id}/recipients/{userId}.
+     */
+    addRecipient(userId: string): Promise<void>;
+    /**
+     * Remove a recipient from this Group DM. Requires Group DM (type GroupDM).
+     * DELETE /channels/{id}/recipients/{userId}.
+     * @param options - silent: if true, does not send a system message (default false)
+     */
+    removeRecipient(userId: string, options?: {
+        silent?: boolean;
+    }): Promise<void>;
+}
+
+/**
+ * Manages channels with fetch and send.
+ * Extends Collection so you can use .get(), .set(), .filter(), etc.
+ */
+declare class ChannelManager extends Collection<string, Channel | GuildChannel> {
+    private readonly client;
+    private readonly maxSize;
+    constructor(client: Client);
+    set(key: string, value: Channel): this;
+    /**
+     * Get a channel from cache or fetch from the API if not present.
+     * Convenience helper to avoid repeating `client.channels.get(id) ?? (await client.channels.fetch(id))`.
+     * @param channelId - Snowflake of the channel
+     * @returns The channel
+     * @throws FluxerError with CHANNEL_NOT_FOUND if the channel does not exist
+     * @example
+     * const channel = await client.channels.resolve(message.channelId);
+     * if (channel?.isTextBased()) await channel.send('Hello!');
+     */
+    resolve(channelId: string): Promise<Channel>;
+    /**
+     * Fetch a channel by ID from the API (or return from cache if present).
+     * @param channelId - Snowflake of the channel
+     * @returns The channel
+     * @throws FluxerError with CHANNEL_NOT_FOUND if the channel does not exist
+     * @example
+     * const channel = await client.channels.fetch(channelId);
+     * if (channel?.isTextBased()) await channel.send('Hello!');
+     */
+    fetch(channelId: string): Promise<Channel>;
+    /**
+     * Fetch a message by ID from the API.
+     * @param channelId - Snowflake of the channel
+     * @param messageId - Snowflake of the message
+     * @returns The message
+     * @throws FluxerError with MESSAGE_NOT_FOUND if the message does not exist
+     * @deprecated Use channel.messages.fetch(messageId). Prefer (await client.channels.resolve(channelId))?.messages?.fetch(messageId).
+     * @example
+     * const channel = await client.channels.resolve(channelId);
+     * const message = await channel?.messages?.fetch(messageId);
+     */
+    fetchMessage(channelId: string, messageId: string): Promise<Message>;
+    /**
+     * Send a message to a channel by ID. Works even when the channel is not cached.
+     * Skips the fetch when you only need to send.
+     * @param channelId - Snowflake of the channel (text channel or DM)
+     * @param payload - Text content or object with content, embeds, and/or files
+     * @returns The created message
+     * @example
+     * await client.channels.send(logChannelId, 'User joined!');
+     * await client.channels.send(channelId, { embeds: [embed] });
+     * await client.channels.send(channelId, { content: 'Report', files: [{ name: 'log.txt', data }] });
+     */
+    send(channelId: string, payload: string | MessageSendOptions): 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;
+    private readonly maxSize;
+    constructor(client: Client);
+    set(key: string, value: Guild): this;
+    /**
+     * Get a guild from cache or fetch from the API if not present.
+     * Convenience helper to avoid repeating `client.guilds.get(id) ?? (await client.guilds.fetch(id))`.
+     * @param guildId - Snowflake of the guild
+     * @returns The guild, or null if not found
+     * @example
+     * const guild = await client.guilds.resolve(message.guildId);
+     * if (guild) console.log(guild.name);
+     */
+    resolve(guildId: string): Promise<Guild | null>;
+    /**
+     * Create a guild. POST /guilds.
+     * @param options - name (required), icon (base64), empty_features
+     * @returns The created guild
+     */
+    create(options: {
+        name: string;
+        icon?: string | null;
+        empty_features?: boolean;
+    }): Promise<Guild>;
+    /**
+     * 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>;
+}
+
+/** Optional cache size limits. When exceeded, oldest entries are evicted (FIFO). Omit or use 0 for unbounded. */
+interface CacheSizeLimits {
+    channels?: number;
+    guilds?: number;
+    users?: number;
+    /** Max messages per channel to cache. Enables channel.messages.get() and oldMessage in messageUpdate. 0 = disabled. */
+    messages?: number;
+}
+interface ClientOptions {
+    rest?: Partial<ConstructorParameters<typeof REST>[0]>;
+    /** Gateway intents. Not yet supported by Fluxer—value is always sent as 0. Set suppressIntentWarning to silence the warning. */
+    intents?: number;
+    /** Suppress the warning when intents are set (Fluxer does not support intents yet). */
+    suppressIntentWarning?: boolean;
+    /** When true, delay the Ready event until all guilds from READY (including unavailable) have been received via GUILD_CREATE. Default: false. */
+    waitForGuilds?: boolean;
+    /** Cache size limits (channels, guilds, users). When exceeded, oldest entries are evicted. Omit or 0 = unbounded. */
+    cache?: CacheSizeLimits;
+    /** Initial presence (status, custom_status, etc.) sent on identify. Can also update via PresenceUpdate after connect. */
+    presence?: GatewayPresenceUpdateData;
+    /** Optional WebSocket constructor (e.g. `require('ws')` in Node for compatibility) */
+    WebSocket?: new (url: string) => {
+        send(data: string | ArrayBufferLike): void;
+        close(code?: number): void;
+        readyState: number;
+        addEventListener?(type: string, listener: (e: unknown) => void): void;
+        on?(event: string, cb: (data?: unknown) => void): void;
+    };
+}
+
+declare class ClientUser extends User {
+    readonly client: Client;
+    constructor(client: Client, data: APIUserPartial);
+    /**
+     * Fetch guilds the bot is a member of.
+     * @returns Array of Guild objects (cached in client.guilds)
+     */
+    fetchGuilds(): Promise<Guild[]>;
+    /**
+     * Leave a guild. Requires the bot to be a member.
+     * @param guildId - The guild ID to leave
+     */
+    leaveGuild(guildId: string): Promise<void>;
+}
+
+/** Event name constants for client.on(Events.X, handler). Use with ClientEvents for typed callbacks. */
+declare const Events: {
+    readonly Ready: "ready";
+    readonly MessageCreate: "messageCreate";
+    readonly MessageUpdate: "messageUpdate";
+    readonly MessageDelete: "messageDelete";
+    readonly MessageDeleteBulk: "messageDeleteBulk";
+    readonly MessageReactionAdd: "messageReactionAdd";
+    readonly MessageReactionRemove: "messageReactionRemove";
+    readonly MessageReactionRemoveAll: "messageReactionRemoveAll";
+    readonly MessageReactionRemoveEmoji: "messageReactionRemoveEmoji";
+    readonly InteractionCreate: "interactionCreate";
+    readonly GuildCreate: "guildCreate";
+    readonly GuildUpdate: "guildUpdate";
+    readonly GuildDelete: "guildDelete";
+    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 GuildMembersChunk: "guildMembersChunk";
+    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";
+};
+
+/** Result of {@link UsersManager.fetchWithProfile}. */
+interface FetchedUserWithProfile {
+    /** The user (cached in client.users). */
+    user: User;
+    /** Raw user data from GET /users/{id}. */
+    userData: APIUserPartial;
+    /** Global profile (bio, pronouns, mutual guilds, etc.). Null if unavailable. */
+    globalProfile: APIProfileResponse | null;
+    /** Server-specific profile when guildId was provided. Null if unavailable. */
+    serverProfile: APIProfileResponse | null;
+    /** Guild member when guildId was provided and user is in the guild. Null otherwise. */
+    member: GuildMember | null;
+    /** Raw member data when member exists (for premium_since, etc.). */
+    memberData: (APIGuildMember & {
+        user: {
+            id: string;
+        };
+    }) | null;
+}
+/**
+ * Manages users with fetch and profile helpers.
+ * Extends Collection so you can use .get(), .set(), .filter(), etc.
+ */
+declare class UsersManager extends Collection<string, User> {
+    private readonly client;
+    private readonly maxSize;
+    constructor(client: Client);
+    set(key: string, value: User): this;
+    /**
+     * Fetch a user by ID from the API.
+     * Updates cache if user already exists.
+     * @param userId - Snowflake of the user
+     * @returns The user
+     * @throws FluxerError (or REST error) if user not found
+     * @example
+     * const user = await client.users.fetch(userId);
+     * console.log(user.username);
+     */
+    fetch(userId: string): Promise<User>;
+    /**
+     * Fetch a user with full profile and optional guild context.
+     * Returns user, global profile, server profile (when guildId), and member (when guildId).
+     * Ideal for userinfo commands.
+     * @param userId - Snowflake of the user
+     * @param options - Optional guildId for server profile and member data
+     * @returns User, raw data, profiles, and member (when in guild)
+     * @throws FluxerError (or REST error) if user not found
+     * @example
+     * const { user, globalProfile, serverProfile, member } = await client.users.fetchWithProfile(
+     *   userId,
+     *   { guildId: message.guildId ?? undefined },
+     * );
+     */
+    fetchWithProfile(userId: string, options?: {
+        guildId?: string | null;
+    }): Promise<FetchedUserWithProfile>;
+}
+
+/** Minimal message data for MessageDelete when the full message is not available. */
+interface PartialMessage {
+    id: string;
+    channelId: string;
+    channel?: Channel | null;
+    /** Message content, when provided by the gateway (e.g. Fluxer). */
+    content?: string | null;
+    /** Author user ID, when provided by the gateway (e.g. Fluxer). */
+    authorId?: string | null;
+}
+
+/**
+ * Callback parameter types for client events. Use with client.on(Events.X, handler).
+ * @see Events
+ */
+interface ClientEvents {
+    [Events.Ready]: [];
+    [Events.MessageCreate]: [message: Message];
+    [Events.MessageUpdate]: [oldMessage: Message | null, newMessage: Message];
+    [Events.MessageDelete]: [message: PartialMessage];
+    [Events.MessageReactionAdd]: [
+        reaction: MessageReaction,
+        user: User,
+        messageId: string,
+        channelId: string,
+        emoji: GatewayReactionEmoji,
+        userId: string
+    ];
+    [Events.MessageReactionRemove]: [
+        reaction: MessageReaction,
+        user: User,
+        messageId: string,
+        channelId: string,
+        emoji: GatewayReactionEmoji,
+        userId: string
+    ];
+    [Events.MessageReactionRemoveAll]: [data: GatewayMessageReactionRemoveAllDispatchData];
+    [Events.MessageReactionRemoveEmoji]: [data: GatewayMessageReactionRemoveEmojiDispatchData];
+    [Events.InteractionCreate]: [interaction: APIApplicationCommandInteraction];
+    [Events.GuildCreate]: [guild: Guild];
+    [Events.GuildUpdate]: [oldGuild: Guild, newGuild: Guild];
+    [Events.GuildDelete]: [guild: Guild];
+    [Events.ChannelCreate]: [channel: GuildChannel];
+    [Events.ChannelUpdate]: [oldChannel: Channel, newChannel: Channel];
+    [Events.ChannelDelete]: [channel: Channel];
+    [Events.GuildMemberAdd]: [member: GuildMember];
+    [Events.GuildMemberUpdate]: [oldMember: GuildMember, newMember: GuildMember];
+    [Events.GuildMemberRemove]: [member: GuildMember];
+    [Events.GuildMembersChunk]: [data: GatewayGuildMembersChunkDispatchData];
+    [Events.VoiceStateUpdate]: [data: GatewayVoiceStateUpdateDispatchData];
+    [Events.VoiceServerUpdate]: [data: GatewayVoiceServerUpdateDispatchData];
+    [Events.VoiceStatesSync]: [
+        data: {
+            guildId: string;
+            voiceStates: Array<{
+                user_id: string;
+                channel_id: string | null;
+            }>;
+        }
+    ];
+    [Events.MessageDeleteBulk]: [data: GatewayMessageDeleteBulkDispatchData];
+    [Events.GuildBanAdd]: [ban: GuildBan];
+    [Events.GuildBanRemove]: [ban: GuildBan];
+    [Events.GuildEmojisUpdate]: [data: GatewayGuildEmojisUpdateDispatchData];
+    [Events.GuildStickersUpdate]: [data: GatewayGuildStickersUpdateDispatchData];
+    [Events.GuildIntegrationsUpdate]: [data: GatewayGuildIntegrationsUpdateDispatchData];
+    [Events.GuildRoleCreate]: [data: GatewayGuildRoleCreateDispatchData];
+    [Events.GuildRoleUpdate]: [data: GatewayGuildRoleUpdateDispatchData];
+    [Events.GuildRoleDelete]: [data: GatewayGuildRoleDeleteDispatchData];
+    [Events.GuildScheduledEventCreate]: [data: GatewayGuildScheduledEventCreateDispatchData];
+    [Events.GuildScheduledEventUpdate]: [data: GatewayGuildScheduledEventUpdateDispatchData];
+    [Events.GuildScheduledEventDelete]: [data: GatewayGuildScheduledEventDeleteDispatchData];
+    [Events.ChannelPinsUpdate]: [data: GatewayChannelPinsUpdateDispatchData];
+    [Events.InviteCreate]: [invite: Invite];
+    [Events.InviteDelete]: [data: GatewayInviteDeleteDispatchData];
+    [Events.TypingStart]: [data: GatewayTypingStartDispatchData];
+    [Events.UserUpdate]: [data: GatewayUserUpdateDispatchData];
+    [Events.PresenceUpdate]: [data: GatewayPresenceUpdateDispatchData];
+    [Events.WebhooksUpdate]: [data: GatewayWebhooksUpdateDispatchData];
+    [Events.Resumed]: [];
+    [Events.Error]: [error: Error];
+    [Events.Debug]: [message: string];
+}
+type ClientEventName = keyof ClientEvents;
+type ClientEventListener<K extends ClientEventName> = (...args: ClientEvents[K]) => void;
+/** Typed event handler methods. Use client.events.MessageReactionAdd((reaction, user, messageId, channelId, emoji, userId) => {...}) or client.on(Events.MessageReactionAdd, ...). */
+type ClientEventMethods = {
+    [K in keyof typeof Events]: (cb: (...args: ClientEvents[(typeof Events)[K]]) => void) => Client;
+};
+/** Main Fluxer bot client. Connects to the gateway, emits events, and provides REST access. */
+declare class Client extends EventEmitter {
+    readonly options: ClientOptions;
+    readonly rest: REST;
+    readonly guilds: GuildManager;
+    readonly channels: ChannelManager;
+    readonly users: UsersManager;
+    /** Typed event handlers. Use client.events.MessageReactionAdd((reaction, user, messageId, channelId, emoji, userId) => {...}) or client.on(Events.MessageReactionAdd, ...). */
+    readonly events: ClientEventMethods;
+    /** The authenticated bot user. Null until READY is received. */
+    user: ClientUser | null;
+    /** Timestamp when the client became ready. Null until READY is received. */
+    readyAt: Date | null;
+    private _ws;
+    /** When waitForGuilds, set of guild IDs we're waiting for GUILD_CREATE on. Null when not waiting. */
+    _pendingGuildIds: Set<string> | null;
+    /** Timeout for guild stream when READY has no guilds (gateway sends only GUILD_CREATE). Cleared in finally. */
+    private _guildStreamSettleTimeout;
+    /** Per-channel message cache (channelId -> messageId -> APIMessage). Used when options.cache.messages > 0. */
+    private _messageCaches;
+    /** @param options - Token, REST config, WebSocket, presence, etc. */
+    constructor(options?: ClientOptions);
+    /** Typed EventEmitter.on for known client events. */
+    on<K extends ClientEventName>(event: K, listener: ClientEventListener<K>): this;
+    on(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    /** Typed EventEmitter.once for known client events. */
+    once<K extends ClientEventName>(event: K, listener: ClientEventListener<K>): this;
+    once(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    /** Typed EventEmitter.off for known client events. */
+    off<K extends ClientEventName>(event: K, listener: ClientEventListener<K>): this;
+    off(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    /** Typed EventEmitter.emit for known client events. */
+    emit<K extends ClientEventName>(event: K, ...args: ClientEvents[K]): boolean;
+    emit(event: string | symbol, ...args: unknown[]): boolean;
+    /**
+     * 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.
+     * When reacting in a guild channel, custom emojis must be from that guild.
+     * @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>;
+    /**
+     * Asserts that a custom emoji (by id) belongs to the given guild.
+     * Used when reacting in guild channels to reject emojis from other servers.
+     * @throws FluxerError with EMOJI_NOT_IN_GUILD if the emoji is not in the guild
+     */
+    private assertEmojiInGuild;
+    /**
+     * Fetch instance discovery info (API URL, gateway URL, features).
+     * Uses canonical GET /.well-known/fluxer.
+     * Does not require authentication.
+     */
+    fetchInstance(): Promise<APIInstance>;
+    /**
+     * Fetch gateway connection metadata (WebSocket URL, recommended shards, session limits).
+     * Uses authenticated GET /gateway/bot.
+     */
+    fetchGatewayInfo(): Promise<APIGatewayBotResponse>;
+    /**
+     * 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
+     * @throws FluxerError with MESSAGE_NOT_FOUND if the message does not exist
+     * @deprecated Use channel.messages.fetch(messageId). For IDs-only: (await client.channels.resolve(channelId))?.messages?.fetch(messageId)
+     * @example
+     * const channel = await client.channels.resolve(channelId);
+     * const message = await channel?.messages?.fetch(messageId);
+     */
+    fetchMessage(channelId: string, messageId: string): Promise<Message>;
+    /**
+     * Send a message to any channel by ID. Shorthand for client.channels.send().
+     * Works even when the channel is not cached.
+     * @deprecated Use client.channels.send(channelId, payload).
+     */
+    sendToChannel(channelId: string, payload: string | MessageSendOptions): Promise<Message>;
+    /**
+     * Get the message cache for a channel. Returns null if message caching is disabled.
+     * Used by MessageManager.get() and event handlers.
+     * @internal
+     */
+    _getMessageCache(channelId: string): Map<string, APIMessage> | null;
+    /**
+     * Add a message to the channel cache. Evicts oldest (FIFO) when over limit.
+     * @internal
+     */
+    _addMessageToCache(channelId: string, data: APIMessage): void;
+    /**
+     * Remove a message from the channel cache.
+     * @internal
+     */
+    _removeMessageFromCache(channelId: string, messageId: string): void;
+    /**
+     * 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).
+     * @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>;
+    /**
+     * Called when all guilds have been received (or immediately if not waiting).
+     * Sets readyAt, emits Ready, clears pending state.
+     */
+    _finalizeReady(): void;
+    /**
+     * Called by GUILD_CREATE handler when waitForGuilds is enabled.
+     * Removes guild from pending set; when empty, finalizes ready.
+     */
+    _onGuildReceived(guildId: string): void;
+    /** 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']>;
+    };
+    /**
+     * Throws if the client is not ready. Use before accessing client.user or other post-ready state.
+     * @throws FluxerError with CLIENT_NOT_READY if client has not received Ready yet
+     */
+    assertReady(): asserts this is Client & {
+        user: NonNullable<Client['user']>;
+    };
+    static get Routes(): typeof Routes;
+}
+
+interface FluxerErrorOptions {
+    code?: string;
+    cause?: Error;
+}
+declare class FluxerError extends Error {
+    readonly code?: string;
+    constructor(message: string, options?: FluxerErrorOptions);
+}
+
+declare const ErrorCodes: {
+    readonly ClientNotReady: "CLIENT_NOT_READY";
+    readonly InvalidToken: "INVALID_TOKEN";
+    readonly AlreadyLoggedIn: "ALREADY_LOGGED_IN";
+    readonly ChannelNotFound: "CHANNEL_NOT_FOUND";
+    readonly MessageNotFound: "MESSAGE_NOT_FOUND";
+    readonly GuildNotFound: "GUILD_NOT_FOUND";
+    readonly MemberNotFound: "MEMBER_NOT_FOUND";
+    readonly RoleNotFound: "ROLE_NOT_FOUND";
+    readonly EmojiNotInGuild: "EMOJI_NOT_IN_GUILD";
+    readonly EmojiNotFound: "EMOJI_NOT_FOUND";
+};
+
+/** User Content CDN (avatars, icons, banners, emojis, attachments). */
+declare const CDN_URL = "https://fluxerusercontent.com";
+/** Static Assets CDN (default avatars). Use fluxerstatic.com for default avatars per Fluxer API. */
+declare const STATIC_CDN_URL = "https://fluxerstatic.com";
+
+interface CdnUrlOptions {
+    size?: number;
+    extension?: string;
+}
+/**
+ * Build a user avatar URL from raw API data.
+ * @param userId - The user's snowflake ID
+ * @param avatarHash - The avatar hash from the API, or null if no custom avatar
+ * @param options - Optional size and extension (default: png; auto-detects gif for a_ hashes)
+ * @returns The avatar URL, or null if no avatar hash
+ * @example
+ * const url = cdnAvatarURL(userData.id, userData.avatar, { size: 256 });
+ */
+declare function cdnAvatarURL(userId: string, avatarHash: string | null, options?: CdnUrlOptions): string | null;
+/**
+ * Build an avatar URL, or the default avatar when none set.
+ * @param userId - The user's snowflake ID
+ * @param avatarHash - The avatar hash from the API, or null
+ * @param options - Optional size and extension
+ * @returns The avatar URL (never null)
+ * @example
+ * const url = cdnDisplayAvatarURL(user.id, user.avatar, { size: 64 });
+ */
+declare function cdnDisplayAvatarURL(userId: string, avatarHash: string | null, options?: CdnUrlOptions): string;
+/**
+ * Build a user or guild banner URL from raw API data.
+ * @param resourceId - The user ID or guild ID
+ * @param bannerHash - The banner hash from the API, or null
+ * @param options - Optional size and extension (default: png; auto-detects gif for a_ hashes)
+ * @returns The banner URL, or null if no banner
+ * @example
+ * const url = cdnBannerURL(userData.id, profile.banner, { size: 512 });
+ */
+declare function cdnBannerURL(resourceId: string, bannerHash: string | null, options?: CdnUrlOptions): string | null;
+/**
+ * Build a guild member avatar URL (guild-specific avatar).
+ * @param guildId - The guild ID
+ * @param userId - The user ID
+ * @param avatarHash - The member avatar hash, or null
+ * @param options - Optional size and extension
+ * @returns The member avatar URL, or null if no guild avatar
+ * @example
+ * const url = cdnMemberAvatarURL(member.guild.id, member.id, member.avatar);
+ */
+declare function cdnMemberAvatarURL(guildId: string, userId: string, avatarHash: string | null, options?: CdnUrlOptions): string | null;
+/**
+ * Build a guild member banner URL (guild-specific banner).
+ * @param guildId - The guild ID
+ * @param userId - The user ID
+ * @param bannerHash - The member banner hash, or null
+ * @param options - Optional size and extension
+ * @returns The member banner URL, or null if no guild banner
+ */
+declare function cdnMemberBannerURL(guildId: string, userId: string, bannerHash: string | null, options?: CdnUrlOptions): string | null;
+/**
+ * Get the default avatar URL (used when user has no custom avatar).
+ * Fluxer uses fluxerstatic.com with index = userId % 6 (six default avatar variants).
+ * @param userIdOrIndex - User ID (snowflake string) to derive index, or explicit index 0-5
+ * @returns The default avatar URL
+ */
+declare function cdnDefaultAvatarURL(userIdOrIndex: string | number): string;
+
+export { Base, CDN_URL, CategoryChannel, type CdnUrlOptions, Channel, ChannelManager, Client, type ClientEventMethods, type ClientEvents, ClientUser, type CollectedReaction, DMChannel, ErrorCodes, Events, type FetchedUserWithProfile, FluxerError, type FluxerErrorOptions, Guild, GuildBan, GuildChannel, GuildEmoji, GuildMember, GuildMemberManager, GuildMemberRoleManager, GuildSticker, Invite, LinkChannel, Message, MessageCollector, type MessageCollectorEndReason, type MessageCollectorOptions, type MessageEditOptions, MessageManager, MessageReaction, type MessageSendOptions, type PartialMessage, ReactionCollector, type ReactionCollectorEndReason, type ReactionCollectorOptions, type ReplyOptions, Role, type RoleResolvable, STATIC_CDN_URL, TextChannel, User, UsersManager, VoiceChannel, Webhook, type WebhookSendOptions, cdnAvatarURL, cdnBannerURL, cdnDefaultAvatarURL, cdnDisplayAvatarURL, cdnMemberAvatarURL, cdnMemberBannerURL };