novaapp-sdk 1.4.0 → 1.4.1

package/dist/index.d.mts

@@ -1,4 +1,5 @@
 import { EventEmitter } from 'node:events';
+import { EventEmitter as EventEmitter$1 } from 'events';
 
 /**
  * Lightweight HTTP client for the Nova Bot API.
@@ -315,7 +316,7 @@ interface RegisteredContextCommand {
     enabled: boolean;
     createdAt: string;
 }
-type BotEventType = 'message.created' | 'message.edited' | 'message.deleted' | 'message.reaction_added' | 'message.reaction_removed' | 'message.pinned' | 'user.joined_server' | 'user.left_server' | 'user.updated_profile' | 'user.banned' | 'user.unbanned' | 'user.role_added' | 'user.role_removed' | 'user.started_typing' | 'user.voice_joined' | 'user.voice_left' | 'interaction.slash_command' | 'interaction.button_click' | 'interaction.select_menu' | 'interaction.modal_submit' | 'interaction.autocomplete' | 'server.updated' | 'channel.created' | 'channel.deleted' | 'channel.updated' | 'role.created' | 'role.updated' | 'role.deleted';
+type BotEventType = 'message.created' | 'message.edited' | 'message.deleted' | 'message.reaction_added' | 'message.reaction_removed' | 'message.pinned' | 'user.joined_server' | 'user.left_server' | 'user.updated_profile' | 'user.banned' | 'user.unbanned' | 'user.role_added' | 'user.role_removed' | 'user.started_typing' | 'user.voice_joined' | 'user.voice_left' | 'interaction.slash_command' | 'interaction.button_click' | 'interaction.select_menu' | 'interaction.modal_submit' | 'interaction.autocomplete' | 'server.updated' | 'channel.created' | 'channel.deleted' | 'channel.updated' | 'role.created' | 'role.updated' | 'role.deleted' | 'invite.created' | 'invite.deleted' | 'forum.post.created' | 'event.created' | 'event.updated' | 'event.deleted' | 'category.created' | 'category.updated' | 'category.deleted' | 'member.warned' | 'messages.bulk_deleted';
 interface BotEvent<T = unknown> {
     type: BotEventType;
     data: T;
@@ -536,6 +537,179 @@ interface NovaClientOptions {
      */
     baseUrl?: string;
 }
+interface ChannelCategory {
+    id: string;
+    serverId: string;
+    name: string;
+    position: number;
+    createdAt: string;
+}
+interface CreateCategoryOptions {
+    name: string;
+    position?: number;
+}
+interface EditCategoryOptions {
+    name?: string;
+    position?: number;
+}
+interface ForumPost {
+    id: string;
+    channelId: string;
+    authorId: string;
+    title: string;
+    body: string;
+    tags: string[];
+    pinned: boolean;
+    closed: boolean;
+    upvoteCount: number;
+    replyCount: number;
+    author: {
+        id: string;
+        username: string;
+        displayName: string;
+        avatar: string | null;
+    };
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateForumPostOptions {
+    title: string;
+    body: string;
+    tags?: string[];
+}
+interface EditForumPostOptions {
+    title?: string;
+    body?: string;
+    tags?: string[];
+    pinned?: boolean;
+    closed?: boolean;
+}
+interface FetchForumPostsOptions {
+    limit?: number;
+    before?: string;
+}
+interface ServerEvent {
+    id: string;
+    serverId: string;
+    channelId: string | null;
+    createdById: string;
+    title: string;
+    description: string | null;
+    imageUrl: string | null;
+    location: string | null;
+    startAt: string;
+    endAt: string | null;
+    attendeeCount?: number;
+    createdAt: string;
+}
+interface ServerEventAttendee {
+    eventId: string;
+    userId: string;
+    status: 'GOING' | 'MAYBE' | 'NOT_GOING';
+    user: {
+        id: string;
+        username: string;
+        displayName: string;
+        avatar: string | null;
+    };
+    createdAt: string;
+}
+interface CreateEventOptions {
+    title: string;
+    description?: string;
+    imageUrl?: string;
+    location?: string;
+    startAt: string;
+    endAt?: string;
+    channelId?: string;
+}
+interface EditEventOptions {
+    title?: string;
+    description?: string;
+    imageUrl?: string;
+    location?: string;
+    startAt?: string;
+    endAt?: string | null;
+}
+interface FetchEventsOptions {
+    limit?: number;
+    /** Only return events starting from now. */
+    upcoming?: boolean;
+}
+interface MemberXPData {
+    userId: string;
+    xp: number;
+    level: number;
+    joinedAt?: string;
+}
+interface LeaderboardEntry extends MemberXPData {
+    rank: number;
+    user: {
+        id: string;
+        username: string;
+        displayName: string;
+        avatar: string | null;
+    };
+}
+interface Warning {
+    id: string;
+    serverId: string;
+    userId: string;
+    moderatorId: string;
+    reason: string;
+    createdAt: string;
+}
+interface FetchWarningsOptions {
+    userId?: string;
+}
+type AutoModRuleType$1 = 'BLOCKED_WORD' | 'BLOCKED_LINK';
+interface AutoModRule {
+    id: string;
+    serverId: string;
+    type: AutoModRuleType$1;
+    value: string;
+    enabled: boolean;
+    createdAt: string;
+}
+interface CreateAutoModRuleOptions {
+    type: AutoModRuleType$1;
+    value: string;
+    enabled?: boolean;
+}
+interface EditAutoModRuleOptions {
+    value?: string;
+    enabled?: boolean;
+}
+interface UserProfile {
+    id: string;
+    username: string;
+    displayName: string;
+    avatar: string | null;
+    status: 'ONLINE' | 'IDLE' | 'DND' | 'OFFLINE';
+    bio: string | null;
+    isBot: boolean;
+    createdAt: string;
+}
+interface SoundboardClip {
+    id: string;
+    serverId: string;
+    name: string;
+    fileUrl: string;
+    duration: number;
+    uploadedById: string;
+    createdAt: string;
+}
+interface ServerStats {
+    serverId: string;
+    memberCount: number;
+    channelCount: number;
+    roleCount: number;
+    onlineCount: number;
+    messageCount: number;
+}
+interface BulkDeleteResult {
+    deleted: number;
+}
 
 declare class MessagesAPI {
     private readonly http;
@@ -797,6 +971,64 @@ declare class MembersAPI {
     removeRole(serverId: string, userId: string, roleId: string): Promise<{
         ok: true;
     }>;
+    /**
+     * Issue a warning to a member.
+     * Requires the `members.moderate` scope.
+     *
+     * @example
+     * await client.members.warn('server-id', 'user-id', 'Spamming')
+     */
+    warn(serverId: string, userId: string, reason: string): Promise<Warning>;
+    /**
+     * Fetch warnings for a server (or optionally a specific user).
+     * Requires the `members.moderate` scope.
+     *
+     * @example
+     * const all = await client.members.fetchWarnings('server-id')
+     * const userWarnings = await client.members.fetchWarnings('server-id', { userId: 'user-id' })
+     */
+    fetchWarnings(serverId: string, options?: FetchWarningsOptions): Promise<Warning[]>;
+    /**
+     * Remove a warning by its ID.
+     * Requires the `members.moderate` scope.
+     *
+     * @example
+     * await client.members.removeWarning('warning-id')
+     */
+    removeWarning(warningId: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Get a member's XP and level.
+     * Requires the `members.read` scope.
+     *
+     * @example
+     * const xpData = await client.members.getXP('server-id', 'user-id')
+     * console.log(`Level ${xpData.level} — ${xpData.xp} XP`)
+     */
+    getXP(serverId: string, userId: string): Promise<MemberXPData>;
+    /**
+     * Set or add XP to a member.
+     * Requires the `members.manage` scope.
+     *
+     * @example
+     * // Add 50 XP
+     * await client.members.setXP('server-id', 'user-id', { add: 50 })
+     * // Set XP to a specific value
+     * await client.members.setXP('server-id', 'user-id', { xp: 1000 })
+     */
+    setXP(serverId: string, userId: string, options: {
+        xp?: number;
+        add?: number;
+    }): Promise<MemberXPData>;
+    /**
+     * Get the XP leaderboard for a server.
+     * Requires the `members.read` scope.
+     *
+     * @example
+     * const top10 = await client.members.leaderboard('server-id', 10)
+     */
+    leaderboard(serverId: string, limit?: number): Promise<LeaderboardEntry[]>;
 }
 
 declare class ServersAPI {
@@ -836,6 +1068,28 @@ declare class ServersAPI {
      * const adminRole = roles.find(r => r.name === 'Admin')
      */
     listRoles(serverId: string): Promise<Role[]>;
+    /**
+     * Fetch all channel categories in a server.
+     *
+     * @example
+     * const categories = await client.servers.listCategories('server-id')
+     */
+    listCategories(serverId: string): Promise<ChannelCategory[]>;
+    /**
+     * Get server statistics (member count, message count, etc.).
+     *
+     * @example
+     * const stats = await client.servers.getStats('server-id')
+     * console.log(`${stats.onlineCount} online / ${stats.memberCount} total`)
+     */
+    getStats(serverId: string): Promise<ServerStats>;
+    /**
+     * Fetch all soundboard clips uploaded to a server.
+     *
+     * @example
+     * const clips = await client.servers.listSoundboard('server-id')
+     */
+    listSoundboard(serverId: string): Promise<SoundboardClip[]>;
 }
 
 declare class InteractionsAPI {
@@ -1054,6 +1308,16 @@ declare class ChannelsAPI {
     startTyping(channelId: string): Promise<{
         ok: true;
     }>;
+    /**
+     * Bulk delete up to 100 messages from a channel at once.
+     * Requires the `messages.manage` scope.
+     * Soft-deletes all specified messages in a single operation.
+     *
+     * @example
+     * const result = await client.channels.bulkDelete('channel-id', ['msg1', 'msg2', 'msg3'])
+     * console.log(`Deleted ${result.deleted} messages`)
+     */
+    bulkDelete(channelId: string, messageIds: string[]): Promise<BulkDeleteResult>;
 }
 
 declare class ReactionsAPI {
@@ -1314,6 +1578,172 @@ declare class AuditLogAPI {
     fetch(serverId: string, options?: FetchAuditLogsOptions): Promise<AuditLogEntry[]>;
 }
 
+declare class ForumAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List forum posts in a FORUM channel.
+     *
+     * @example
+     * const posts = await client.forum.list('channel-id')
+     */
+    list(channelId: string, options?: FetchForumPostsOptions): Promise<ForumPost[]>;
+    /**
+     * Create a forum post in a FORUM channel.
+     *
+     * @example
+     * const post = await client.forum.create('channel-id', {
+     *   title: 'Ideas thread',
+     *   body: 'Post your ideas here!',
+     *   tags: ['idea', 'discussion'],
+     * })
+     */
+    create(channelId: string, options: CreateForumPostOptions): Promise<ForumPost>;
+    /**
+     * Edit a forum post.
+     * The bot must be the author of the post.
+     *
+     * @example
+     * await client.forum.edit('post-id', { closed: true })
+     */
+    edit(postId: string, options: EditForumPostOptions): Promise<ForumPost>;
+    /**
+     * Delete a forum post.
+     * The bot must be the author of the post.
+     *
+     * @example
+     * await client.forum.delete('post-id')
+     */
+    delete(postId: string): Promise<void>;
+}
+
+declare class EventsAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List server events.
+     *
+     * @example
+     * const events = await client.events.list('server-id', { upcoming: true })
+     */
+    list(serverId: string, options?: FetchEventsOptions): Promise<ServerEvent[]>;
+    /**
+     * Fetch a single server event by ID.
+     * Returns full attendee list.
+     *
+     * @example
+     * const event = await client.events.fetch('event-id')
+     */
+    fetch(eventId: string): Promise<ServerEvent & {
+        attendees: ServerEventAttendee[];
+    }>;
+    /**
+     * Create a server event.
+     *
+     * @example
+     * const event = await client.events.create('server-id', {
+     *   title: 'Game Night',
+     *   description: 'Friday fun!',
+     *   startAt: new Date(Date.now() + 86400_000).toISOString(),
+     * })
+     */
+    create(serverId: string, options: CreateEventOptions): Promise<ServerEvent>;
+    /**
+     * Edit a server event.
+     *
+     * @example
+     * await client.events.edit('event-id', { title: 'Game Night v2' })
+     */
+    edit(eventId: string, options: EditEventOptions): Promise<ServerEvent>;
+    /**
+     * Delete a server event.
+     *
+     * @example
+     * await client.events.delete('event-id')
+     */
+    delete(eventId: string): Promise<void>;
+}
+
+declare class CategoriesAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List all channel categories in a server, ordered by position.
+     *
+     * @example
+     * const cats = await client.categories.list('server-id')
+     */
+    list(serverId: string): Promise<ChannelCategory[]>;
+    /**
+     * Create a new channel category.
+     *
+     * @example
+     * const cat = await client.categories.create('server-id', { name: 'General', position: 0 })
+     */
+    create(serverId: string, options: CreateCategoryOptions): Promise<ChannelCategory>;
+    /**
+     * Edit an existing channel category.
+     *
+     * @example
+     * await client.categories.edit('cat-id', { name: 'Renamed' })
+     */
+    edit(categoryId: string, options: EditCategoryOptions): Promise<ChannelCategory>;
+    /**
+     * Delete a channel category.
+     *
+     * @example
+     * await client.categories.delete('cat-id')
+     */
+    delete(categoryId: string): Promise<void>;
+}
+
+declare class AutoModAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List all automod rules for a server.
+     *
+     * @example
+     * const rules = await client.automod.list('server-id')
+     */
+    list(serverId: string): Promise<AutoModRule[]>;
+    /**
+     * Create a new automod rule.
+     *
+     * @example
+     * await client.automod.create('server-id', { type: 'BLOCKED_WORD', value: 'badword' })
+     * await client.automod.create('server-id', { type: 'BLOCKED_LINK', value: 'example.com' })
+     */
+    create(serverId: string, options: CreateAutoModRuleOptions): Promise<AutoModRule>;
+    /**
+     * Enable / disable a rule or update the blocked value.
+     *
+     * @example
+     * await client.automod.edit('rule-id', { enabled: false })
+     */
+    edit(ruleId: string, options: EditAutoModRuleOptions): Promise<AutoModRule>;
+    /**
+     * Delete an automod rule.
+     *
+     * @example
+     * await client.automod.delete('rule-id')
+     */
+    delete(ruleId: string): Promise<void>;
+}
+
+declare class UsersAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Fetch a user's public profile by ID.
+     *
+     * @example
+     * const user = await client.users.fetch('user-id')
+     * console.log(user.displayName)
+     */
+    fetch(userId: string): Promise<UserProfile>;
+}
+
 type TextInputStyle = 'short' | 'paragraph';
 /**
  * Fluent builder for a single text-input field inside a modal.
@@ -1746,24 +2176,70 @@ declare class NovaMessage {
      */
     fetch(): Promise<NovaMessage>;
     /**
-     * Get a URL to this message (deep link).
+     * Forward this message's content (and embed if present) to another channel.
+     * Creates a new message in the target channel.
+     *
+     * @example
+     * const forwarded = await msg.forward('target-channel-id')
+     * console.log('Forwarded to:', forwarded.channelId)
      */
-    get url(): string;
+    forward(channelId: string): Promise<NovaMessage>;
     /**
-     * Return the raw message object.
+     * Fetch detailed reaction data for a specific emoji on this message.
+     * Returns the users who reacted with that emoji.
+     *
+     * @example
+     * const reactors = await msg.fetchReactionDetails('👍')
+     * for (const r of reactors) console.log(r.username, 'reacted 👍')
      */
-    toJSON(): Message;
-    toString(): string;
-}
-
-/**
- * A rich wrapper around a raw `Channel` with convenience methods.
- *
- * Returned by `client.fetchChannel()` and `client.fetchChannels()`.
- *
- * @example
- * const channel = await client.fetchChannel('channel-id')
- *
+    fetchReactionDetails(emoji: string): ReturnType<ReactionsAPI['fetchEmoji']>;
+    /**
+     * Remove **all** reactions from this message.
+     * Requires the `messages.manage` scope.
+     *
+     * @example
+     * await msg.clearAllReactions()
+     */
+    clearAllReactions(): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Remove all reactions for a specific emoji from this message.
+     * Requires the `messages.manage` scope.
+     *
+     * @example
+     * await msg.clearReactionsFor('👍')
+     */
+    clearReactionsFor(emoji: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Fetch a breakdown of all reactions on this message, grouped by emoji.
+     *
+     * @example
+     * const details = await msg.fetchAllReactions()
+     * for (const d of details) console.log(`${d.emoji} — ${d.count}`)
+     */
+    fetchAllReactions(): ReturnType<ReactionsAPI['fetch']>;
+    /**
+     * Get a URL to this message (deep link).
+     */
+    get url(): string;
+    /**
+     * Return the raw message object.
+     */
+    toJSON(): Message;
+    toString(): string;
+}
+
+/**
+ * A rich wrapper around a raw `Channel` with convenience methods.
+ *
+ * Returned by `client.fetchChannel()` and `client.fetchChannels()`.
+ *
+ * @example
+ * const channel = await client.fetchChannel('channel-id')
+ *
  * await channel.send('Hello from the bot!')
  * await channel.edit({ topic: 'New topic' })
  * const messages = await channel.fetchMessages({ limit: 20 })
@@ -1787,7 +2263,9 @@ declare class NovaChannel {
     readonly createdAt: Date;
     private readonly _channels;
     private readonly _messages;
-    constructor(raw: Channel, channels: ChannelsAPI, messages: MessagesAPI);
+    private readonly _webhooks;
+    private readonly _forum;
+    constructor(raw: Channel, channels: ChannelsAPI, messages: MessagesAPI, webhooks?: WebhooksAPI, forum?: ForumAPI);
     /** `true` for text channels. */
     isText(): boolean;
     /** `true` for voice channels. */
@@ -1850,6 +2328,51 @@ declare class NovaChannel {
     delete(): Promise<{
         ok: true;
     }>;
+    /**
+     * Bulk-delete multiple messages in this channel (max 100 at once).
+     * Requires the `messages.manage` scope.
+     *
+     * @example
+     * const ids = messages.map(m => m.id)
+     * const result = await channel.bulkDelete(ids)
+     * console.log(`Deleted ${result.deleted} messages`)
+     */
+    bulkDelete(messageIds: string[]): Promise<BulkDeleteResult>;
+    /**
+     * Create a webhook in this channel.
+     * Requires the `webhooks.manage` scope.
+     *
+     * @example
+     * const wh = await channel.createWebhook({ name: 'Notifications' })
+     * console.log('Token:', wh.token)
+     */
+    createWebhook(options: WebhookCreateOptions): Promise<Webhook>;
+    /**
+     * Fetch all webhooks in this channel.
+     * Requires the `webhooks.manage` scope.
+     *
+     * @example
+     * const webhooks = await channel.fetchWebhooks()
+     */
+    fetchWebhooks(): Promise<Webhook[]>;
+    /**
+     * Create a new post in this FORUM channel.
+     * Requires the `channels.write` scope.
+     *
+     * @example
+     * const post = await channel.createForumPost({
+     *   title: 'Announcement',
+     *   content: 'Welcome everyone!',
+     * })
+     */
+    createForumPost(options: CreateForumPostOptions): Promise<ForumPost>;
+    /**
+     * Fetch posts from this FORUM channel.
+     *
+     * @example
+     * const posts = await channel.fetchForumPosts({ limit: 20 })
+     */
+    fetchForumPosts(options?: FetchForumPostsOptions): Promise<ForumPost[]>;
     /**
      * Returns the channel as a mention-style string: `#name`.
      */
@@ -1956,6 +2479,65 @@ declare class NovaMember {
     removeRole(roleId: string): Promise<{
         ok: true;
     }>;
+    /**
+     * Issue a warning to this member.
+     * Requires the `members.moderate` scope.
+     *
+     * @example
+     * await member.warn('Excessive spamming')
+     */
+    warn(reason: string): Promise<Warning>;
+    /**
+     * Fetch all warnings for this member in this server.
+     * Requires the `members.moderate` scope.
+     *
+     * @example
+     * const warnings = await member.fetchWarnings()
+     * console.log(`${warnings.length} warnings on record`)
+     */
+    fetchWarnings(): Promise<Warning[]>;
+    /**
+     * Get this member's current XP and level.
+     * Requires the `members.read` scope.
+     *
+     * @example
+     * const xp = await member.getXP()
+     * console.log(`Level ${xp.level} — ${xp.xp} XP`)
+     */
+    getXP(): Promise<MemberXPData>;
+    /**
+     * Set this member's XP to a specific value.
+     * Requires the `members.manage` scope.
+     *
+     * @example
+     * await member.setXP(500)
+     */
+    setXP(xp: number): Promise<MemberXPData>;
+    /**
+     * Add (or subtract) XP to this member's current total.
+     * Requires the `members.manage` scope.
+     *
+     * @example
+     * await member.addXP(100)   // reward 100 XP
+     * await member.addXP(-50)   // deduct 50 XP
+     */
+    addXP(amount: number): Promise<MemberXPData>;
+    /**
+     * Delete all warnings on record for this member in this server.
+     * Requires the `members.moderate` scope.
+     *
+     * @example
+     * await member.clearWarnings()
+     */
+    clearWarnings(): Promise<number>;
+    /**
+     * Reset this member's XP back to zero.
+     * Requires the `members.manage` scope.
+     *
+     * @example
+     * await member.resetXP()
+     */
+    resetXP(): Promise<MemberXPData>;
     /**
      * Returns a mention-style string: `@displayName`.
      */
@@ -2064,7 +2646,11 @@ declare class NovaServerWrapper {
     private readonly _invites;
     private readonly _roles;
     private readonly _messages;
-    constructor(raw: NovaServer, servers: ServersAPI, channels: ChannelsAPI, members: MembersAPI, invites: InvitesAPI, roles: RolesAPI, messages: MessagesAPI);
+    private readonly _categories;
+    private readonly _events;
+    private readonly _automod;
+    private readonly _auditLog;
+    constructor(raw: NovaServer, servers: ServersAPI, channels: ChannelsAPI, members: MembersAPI, invites: InvitesAPI, roles: RolesAPI, messages: MessagesAPI, categories?: CategoriesAPI, events?: EventsAPI, automod?: AutoModAPI, auditLog?: AuditLogAPI);
     /**
      * Update this server's name, description, or icon.
      * Requires the `server.manage` scope.
@@ -2126,12 +2712,21 @@ declare class NovaServerWrapper {
      */
     fetchBans(): Promise<BanEntry[]>;
     /**
-     * Fetch all custom roles in this server.
+     * List all custom roles in this server, sorted by position.
      *
      * @example
      * const roles = await server.fetchRoles()
+     * const admins = roles.filter(r => r.name === 'Admin')
      */
     fetchRoles(): Promise<Role[]>;
+    /**
+     * Create a new custom role in this server.
+     * Requires the `roles.manage` scope.
+     *
+     * @example
+     * const role = await server.createRole({ name: 'Supporter', color: '#00d4ff', hoist: true })
+     */
+    createRole(options: RoleCreateOptions): Promise<Role>;
     /**
      * Fetch all active invites for this server.
      *
@@ -2154,6 +2749,101 @@ declare class NovaServerWrapper {
      * await server.send('channel-id', 'Hello, server!')
      */
     send(channelId: string, content: string): ReturnType<MessagesAPI['send']>;
+    /**
+     * Fetch all channel categories in this server.
+     *
+     * @example
+     * const cats = await server.fetchCategories()
+     * const general = cats.find(c => c.name === 'General')
+     */
+    fetchCategories(): Promise<ChannelCategory[]>;
+    /**
+     * Create a new channel category in this server.
+     * Requires the `channels.manage` scope.
+     *
+     * @example
+     * const cat = await server.createCategory({ name: 'Bot Channels' })
+     */
+    createCategory(options: CreateCategoryOptions): Promise<ChannelCategory>;
+    /**
+     * Fetch server events. Pass `{ upcoming: true }` to only return future events.
+     *
+     * @example
+     * const events = await server.fetchEvents({ upcoming: true })
+     */
+    fetchEvents(options?: FetchEventsOptions): Promise<ServerEvent[]>;
+    /**
+     * Create a new server event.
+     * Requires the `server.manage` scope.
+     *
+     * @example
+     * const event = await server.createEvent({
+     *   title: 'Game Night',
+     *   startAt: new Date('2025-09-01T20:00:00Z').toISOString(),
+     * })
+     */
+    createEvent(options: CreateEventOptions): Promise<ServerEvent>;
+    /**
+     * Fetch server statistics (member count, message count, etc.).
+     *
+     * @example
+     * const stats = await server.fetchStats()
+     * console.log(`Online: ${stats.onlineCount} / ${stats.memberCount}`)
+     */
+    fetchStats(): Promise<ServerStats>;
+    /**
+     * Fetch the audit log for this server.
+     * Requires the `audit-log.read` scope.
+     *
+     * @example
+     * const log = await server.fetchAuditLog({ action: 'member.banned', limit: 20 })
+     */
+    fetchAuditLog(options?: FetchAuditLogsOptions): Promise<AuditLogEntry[]>;
+    /**
+     * Issue a warning to a member in this server.
+     * Requires the `members.moderate` scope.
+     *
+     * @example
+     * await server.warn('user-id', 'Insulting other members')
+     */
+    warn(userId: string, reason: string): Promise<Warning>;
+    /**
+     * Fetch warnings for this server, optionally filtered by user.
+     * Requires the `members.moderate` scope.
+     *
+     * @example
+     * const all = await server.fetchWarnings()
+     * const userWarns = await server.fetchWarnings({ userId: 'user-id' })
+     */
+    fetchWarnings(options?: {
+        userId?: string;
+    }): Promise<Warning[]>;
+    /**
+     * Fetch the XP leaderboard for this server.
+     * Requires the `members.read` scope.
+     *
+     * @example
+     * const top = await server.fetchLeaderboard(10)
+     * top.forEach(e => console.log(`#${e.rank} ${e.user.displayName} — ${e.xp} XP`))
+     */
+    fetchLeaderboard(limit?: number): Promise<LeaderboardEntry[]>;
+    /**
+     * Fetch all AutoMod rules for this server.
+     * Requires the `server.manage` scope.
+     *
+     * @example
+     * const rules = await server.fetchAutoModRules()
+     * const active = rules.filter(r => r.enabled)
+     */
+    fetchAutoModRules(): Promise<AutoModRule[]>;
+    /**
+     * Create a new AutoMod rule for this server.
+     * Requires the `server.manage` scope.
+     *
+     * @example
+     * await server.createAutoModRule({ type: 'BLOCKED_WORD', value: 'badword' })
+     */
+    createAutoModRule(options: CreateAutoModRuleOptions): Promise<AutoModRule>;
     toJSON(): NovaServer;
 }
 
@@ -2262,107 +2952,358 @@ declare class NovaWebhook {
     toJSON(): Webhook;
 }
 
-interface NovaClientEvents {
-    /** Fired when the bot connects and is identified by the gateway. */
-    ready: (bot: BotApplication) => void;
-    /** Fired for every raw `bot:event` from the gateway. */
-    event: (event: BotEvent) => void;
+/**
+ * A rich wrapper around a raw `ForumPost` object that provides
+ * convenient helper methods for common operations.
+ *
+ * @example
+ * const posts = await client.fetchForumPosts('channel-id')
+ * for (const post of posts) {
+ *   if (post.closed) continue
+ *   await post.close()
+ * }
+ */
+declare class NovaForumPost implements ForumPost {
+    private readonly raw;
+    private readonly forum;
+    readonly id: string;
+    readonly channelId: string;
+    readonly authorId: string;
+    readonly title: string;
+    readonly body: string;
+    readonly tags: string[];
+    readonly pinned: boolean;
+    readonly closed: boolean;
+    readonly upvoteCount: number;
+    readonly replyCount: number;
+    readonly author: ForumPost['author'];
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    constructor(raw: ForumPost, forum: ForumAPI);
     /**
-     * Fired when an interaction is received (slash command, button click, etc.).
-     * Use `client.command()`, `client.button()`, `client.selectMenu()`, or
-     * `client.autocomplete()` for convenient routing instead of handling everything here.
+     * Edit this forum post.
+     *
+     * @example
+     * await post.edit({ title: 'Updated title' })
      */
-    interactionCreate: (interaction: NovaInteraction) => void;
-    /** Fired when the WebSocket connection drops. */
-    disconnect: (reason: string) => void;
-    /** Fired on gateway / API errors. */
-    error: (err: Error | {
-        code: number;
-        message: string;
-    }) => void;
-    /** A new message was sent in a channel the bot can see. */
-    messageCreate: (message: NovaMessage) => void;
-    /** A message was edited. Returns the updated message. */
-    messageUpdate: (message: NovaMessage) => void;
-    /** A message was deleted. Returns partial data. */
-    messageDelete: (data: {
-        id: string;
-        channelId: string;
-    }) => void;
-    /** A reaction was added to a message. */
-    reactionAdd: (data: {
-        messageId: string;
-        channelId: string;
-        userId: string;
-        emoji: string;
-    }) => void;
-    /** A reaction was removed from a message. */
-    reactionRemove: (data: {
-        messageId: string;
-        channelId: string;
-        userId: string;
-        emoji: string;
-    }) => void;
-    /** A member joined a server the bot is in. */
-    memberAdd: (data: {
-        serverId: string;
-        userId: string;
-        username: string;
-    }) => void;
-    /** A member left a server the bot is in. */
-    memberRemove: (data: {
-        serverId: string;
-        userId: string;
-    }) => void;
-    /** A user started typing in a channel. */
-    typingStart: (data: {
-        channelId: string;
-        userId: string;
-    }) => void;
-    /** A message was pinned. */
-    messagePinned: (data: {
-        messageId: string;
-        channelId: string;
-        pinnedBy: string;
-    }) => void;
-    /** A channel was created in a server. */
-    channelCreate: (channel: Channel) => void;
-    /** A channel was updated. */
-    channelUpdate: (channel: Channel) => void;
-    /** A channel was deleted. */
-    channelDelete: (data: {
-        id: string;
-        serverId: string;
-    }) => void;
-    /** A role was created in a server. */
-    roleCreate: (role: Role) => void;
-    /** A role was updated. */
-    roleUpdate: (role: Role) => void;
-    /** A role was deleted. */
-    roleDelete: (data: {
-        id: string;
-        serverId: string;
-    }) => void;
-    /** A user joined a voice channel. */
-    voiceJoin: (data: {
-        userId: string;
-        channelId: string;
-        serverId: string;
-    }) => void;
-    /** A user left a voice channel. */
-    voiceLeave: (data: {
-        userId: string;
-        channelId: string;
-        serverId: string;
-    }) => void;
-    /** A member was banned from a server. */
-    memberBanned: (data: {
-        userId: string;
-        serverId: string;
-        moderatorId: string | null;
-        reason: string | null;
-    }) => void;
-    /** A member was unbanned. */
+    edit(options: EditForumPostOptions): Promise<NovaForumPost>;
+    /**
+     * Close the forum post (no new replies).
+     *
+     * @example
+     * await post.close()
+     */
+    close(): Promise<NovaForumPost>;
+    /**
+     * Re-open a closed forum post.
+     *
+     * @example
+     * await post.open()
+     */
+    open(): Promise<NovaForumPost>;
+    /**
+     * Pin this forum post in the channel.
+     *
+     * @example
+     * await post.pin()
+     */
+    pin(): Promise<NovaForumPost>;
+    /**
+     * Unpin this forum post.
+     *
+     * @example
+     * await post.unpin()
+     */
+    unpin(): Promise<NovaForumPost>;
+    /**
+     * Delete this forum post.
+     *
+     * @example
+     * await post.delete()
+     */
+    delete(): Promise<void>;
+    /** Whether this post was created by the currently connected bot. */
+    get isOwnPost(): boolean;
+    /** Returns `true` if the post has been closed. */
+    get isClosed(): boolean;
+    /** Returns `true` if the post is pinned. */
+    get isPinned(): boolean;
+    toJSON(): ForumPost;
+}
+
+/**
+ * A rich wrapper around a raw `ServerEvent` object.
+ *
+ * @example
+ * const events = await client.fetchEvents('server-id', { upcoming: true })
+ * for (const event of events) {
+ *   console.log(`${event.title} starts at ${event.startAt}`)
+ * }
+ */
+declare class NovaServerEvent implements ServerEvent {
+    private readonly raw;
+    private readonly events;
+    readonly id: string;
+    readonly serverId: string;
+    readonly channelId: string | null;
+    readonly createdById: string;
+    readonly title: string;
+    readonly description: string | null;
+    readonly imageUrl: string | null;
+    readonly location: string | null;
+    readonly startAt: string;
+    readonly endAt: string | null;
+    readonly attendeeCount: number | undefined;
+    readonly createdAt: string;
+    constructor(raw: ServerEvent, events: EventsAPI);
+    /**
+     * Edit this event.
+     *
+     * @example
+     * await event.edit({ title: 'New Title' })
+     */
+    edit(options: EditEventOptions): Promise<NovaServerEvent>;
+    /**
+     * Fetch full event details including the attendee list.
+     *
+     * @example
+     * const full = await event.fetchAttendees()
+     * console.log(`${full.attendees.length} attendees`)
+     */
+    fetchAttendees(): Promise<{
+        event: NovaServerEvent;
+        attendees: ServerEventAttendee[];
+    }>;
+    /**
+     * Delete this event.
+     *
+     * @example
+     * await event.delete()
+     */
+    delete(): Promise<void>;
+    /**
+     * Whether the event has already started.
+     */
+    get hasStarted(): boolean;
+    /**
+     * Whether the event has ended.
+     * Returns `false` if no `endAt` is set.
+     */
+    get hasEnded(): boolean;
+    /**
+     * Whether this is an upcoming event that has not yet started.
+     */
+    get isUpcoming(): boolean;
+    toJSON(): ServerEvent;
+}
+
+/**
+ * A rich wrapper around a raw `BanEntry` that adds an `unban()` convenience method.
+ *
+ * Returned by `client.fetchBans()`.
+ *
+ * @example
+ * const bans = await client.fetchBans('server-id')
+ * for (const ban of bans) {
+ *   if (ban.reason === 'testing') {
+ *     await ban.unban()
+ *     console.log(`Unbanned ${ban.displayName}`)
+ *   }
+ * }
+ */
+declare class NovaBan implements BanEntry {
+    /** The banned user's ID. */
+    readonly userId: string;
+    /** The banned user's username. */
+    readonly username: string;
+    /** The banned user's display name. */
+    readonly displayName: string;
+    /** The banned user's avatar URL, or `null`. */
+    readonly avatar: string | null;
+    /** The reason for the ban, or `null`. */
+    readonly reason: string | null;
+    /** ISO timestamp of when the ban was issued. */
+    readonly bannedAt: string;
+    /** ID of the moderator who issued the ban, or `null`. */
+    readonly moderatorId: string | null;
+    /** ID of the server this ban belongs to. */
+    readonly serverId: string;
+    private readonly _members;
+    constructor(raw: BanEntry, serverId: string, members: MembersAPI);
+    /**
+     * Revoke this ban, allowing the user to rejoin the server.
+     * Requires the `members.ban` scope.
+     *
+     * @example
+     * await ban.unban()
+     */
+    unban(): Promise<{
+        ok: true;
+    }>;
+    /**
+     * When the ban was issued as a `Date` object.
+     */
+    get bannedAtDate(): Date;
+    /**
+     * Human-readable label: `"displayName (username)"`.
+     */
+    get label(): string;
+    toJSON(): BanEntry;
+}
+
+/**
+ * A rich wrapper around a raw `Warning` that adds a `delete()` convenience method.
+ *
+ * Returned by `client.fetchMemberWarnings()` and `member.fetchWarnings()`.
+ *
+ * @example
+ * const warnings = await member.fetchWarnings()
+ * for (const warning of warnings) {
+ *   console.log(`[${warning.issuedAt.toLocaleDateString()}] ${warning.reason}`)
+ * }
+ *
+ * // Remove the oldest warning if there are too many
+ * if (warnings.length > 5) {
+ *   await warnings[0].delete()
+ * }
+ */
+declare class NovaWarning implements Warning {
+    /** Unique ID of this warning. */
+    readonly id: string;
+    /** ID of the server where the warning was issued. */
+    readonly serverId: string;
+    /** ID of the user who received the warning. */
+    readonly userId: string;
+    /** ID of the moderator who issued the warning. */
+    readonly moderatorId: string;
+    /** The reason text. */
+    readonly reason: string;
+    /** ISO timestamp of when the warning was issued. */
+    readonly createdAt: string;
+    private readonly _members;
+    constructor(raw: Warning, members: MembersAPI);
+    /**
+     * Delete (expunge) this warning from the record.
+     * Requires the `members.moderate` scope.
+     *
+     * @example
+     * await warning.delete()
+     */
+    delete(): Promise<{
+        ok: true;
+    }>;
+    /**
+     * When the warning was issued as a `Date` object.
+     */
+    get issuedAt(): Date;
+    /**
+     * How long ago the warning was issued, in milliseconds.
+     */
+    get ageMs(): number;
+    toJSON(): Warning;
+}
+
+interface NovaClientEvents {
+    /** Fired when the bot connects and is identified by the gateway. */
+    ready: (bot: BotApplication) => void;
+    /** Fired for every raw `bot:event` from the gateway. */
+    event: (event: BotEvent) => void;
+    /**
+     * Fired when an interaction is received (slash command, button click, etc.).
+     * Use `client.command()`, `client.button()`, `client.selectMenu()`, or
+     * `client.autocomplete()` for convenient routing instead of handling everything here.
+     */
+    interactionCreate: (interaction: NovaInteraction) => void;
+    /** Fired when the WebSocket connection drops. */
+    disconnect: (reason: string) => void;
+    /** Fired on gateway / API errors. */
+    error: (err: Error | {
+        code: number;
+        message: string;
+    }) => void;
+    /** A new message was sent in a channel the bot can see. */
+    messageCreate: (message: NovaMessage) => void;
+    /** A message was edited. Returns the updated message. */
+    messageUpdate: (message: NovaMessage) => void;
+    /** A message was deleted. Returns partial data. */
+    messageDelete: (data: {
+        id: string;
+        channelId: string;
+    }) => void;
+    /** A reaction was added to a message. */
+    reactionAdd: (data: {
+        messageId: string;
+        channelId: string;
+        userId: string;
+        emoji: string;
+    }) => void;
+    /** A reaction was removed from a message. */
+    reactionRemove: (data: {
+        messageId: string;
+        channelId: string;
+        userId: string;
+        emoji: string;
+    }) => void;
+    /** A member joined a server the bot is in. */
+    memberAdd: (data: {
+        serverId: string;
+        userId: string;
+        username: string;
+    }) => void;
+    /** A member left a server the bot is in. */
+    memberRemove: (data: {
+        serverId: string;
+        userId: string;
+    }) => void;
+    /** A user started typing in a channel. */
+    typingStart: (data: {
+        channelId: string;
+        userId: string;
+    }) => void;
+    /** A message was pinned. */
+    messagePinned: (data: {
+        messageId: string;
+        channelId: string;
+        pinnedBy: string;
+    }) => void;
+    /** A channel was created in a server. */
+    channelCreate: (channel: Channel) => void;
+    /** A channel was updated. */
+    channelUpdate: (channel: Channel) => void;
+    /** A channel was deleted. */
+    channelDelete: (data: {
+        id: string;
+        serverId: string;
+    }) => void;
+    /** A role was created in a server. */
+    roleCreate: (role: Role) => void;
+    /** A role was updated. */
+    roleUpdate: (role: Role) => void;
+    /** A role was deleted. */
+    roleDelete: (data: {
+        id: string;
+        serverId: string;
+    }) => void;
+    /** A user joined a voice channel. */
+    voiceJoin: (data: {
+        userId: string;
+        channelId: string;
+        serverId: string;
+    }) => void;
+    /** A user left a voice channel. */
+    voiceLeave: (data: {
+        userId: string;
+        channelId: string;
+        serverId: string;
+    }) => void;
+    /** A member was banned from a server. */
+    memberBanned: (data: {
+        userId: string;
+        serverId: string;
+        moderatorId: string | null;
+        reason: string | null;
+    }) => void;
+    /** A member was unbanned. */
     memberUnbanned: (data: {
         userId: string;
         serverId: string;
@@ -2397,6 +3338,38 @@ interface NovaClientEvents {
         code: string;
         serverId: string;
     }) => void;
+    /** A forum post was created in a FORUM channel. */
+    forumPostCreate: (post: NovaForumPost) => void;
+    /** A server event was created. */
+    eventCreate: (event: NovaServerEvent) => void;
+    /** A server event was updated. */
+    eventUpdate: (event: ServerEvent) => void;
+    /** A server event was deleted. */
+    eventDelete: (data: {
+        id: string;
+        serverId: string;
+    }) => void;
+    /** A channel category was created. */
+    categoryCreate: (category: ChannelCategory) => void;
+    /** A channel category was updated. */
+    categoryUpdate: (category: ChannelCategory) => void;
+    /** A channel category was deleted. */
+    categoryDelete: (data: {
+        id: string;
+        serverId: string;
+    }) => void;
+    /** A member received a warning. */
+    memberWarned: (data: {
+        serverId: string;
+        userId: string;
+        warning: Warning;
+    }) => void;
+    /** Multiple messages were bulk-deleted. */
+    messagesBulkDelete: (data: {
+        channelId: string;
+        messageIds: string[];
+        count: number;
+    }) => void;
 }
 /**
  * The main Nova bot client.
@@ -2445,6 +3418,16 @@ declare class NovaClient extends EventEmitter {
     readonly webhooks: WebhooksAPI;
     /** Fetch server audit logs. */
     readonly auditLog: AuditLogAPI;
+    /** Create and manage forum posts in FORUM channels. */
+    readonly forum: ForumAPI;
+    /** Create and manage server events. */
+    readonly events: EventsAPI;
+    /** Manage channel categories. */
+    readonly categories: CategoriesAPI;
+    /** Manage automod rules (blocked words / links). */
+    readonly automod: AutoModAPI;
+    /** Fetch user profiles. */
+    readonly users: UsersAPI;
     private socket;
     private readonly http;
     private readonly options;
@@ -2580,6 +3563,30 @@ declare class NovaClient extends EventEmitter {
      * await member.dm('Welcome!')
      */
     fetchMember(serverId: string, userId: string): Promise<NovaMember>;
+    /**
+     * Fetch all bans in a server and return them as `NovaBan` wrappers.
+     * Each `NovaBan` has an `.unban()` convenience method.
+     * Requires the `members.ban` scope.
+     *
+     * @example
+     * const bans = await client.fetchBans('server-id')
+     * for (const ban of bans) {
+     *   if (ban.reason === 'test') await ban.unban()
+     * }
+     */
+    fetchBans(serverId: string): Promise<NovaBan[]>;
+    /**
+     * Fetch warnings for a member (or all members) in a server and return them
+     * as `NovaWarning` wrappers. Each wrapper has a `.delete()` convenience method.
+     * Requires the `members.moderate` scope.
+     *
+     * @example
+     * const warnings = await client.fetchMemberWarnings('server-id', 'user-id')
+     * for (const w of warnings) {
+     *   if (w.ageMs > 30 * 24 * 60 * 60_000) await w.delete() // older than 30 days
+     * }
+     */
+    fetchMemberWarnings(serverId: string, userId?: string): Promise<NovaWarning[]>;
     /**
      * Fetch a single server by ID and return it as a `NovaServerWrapper`.
      *
@@ -2636,39 +3643,162 @@ declare class NovaClient extends EventEmitter {
      */
     fetchWebhook(webhookId: string): Promise<NovaWebhook>;
     /**
-     * Wait for a specific event to be emitted, optionally filtered.
-     * Rejects after `timeoutMs` (default 30 s) if the condition never fires.
+     * Fetch forum posts from a FORUM channel and return them as `NovaForumPost` wrappers.
      *
      * @example
-     * // Wait for any message in a specific channel
-     * const msg = await client.waitFor('messageCreate', m => m.channelId === channelId)
+     * const posts = await client.fetchForumPosts('channel-id', { limit: 20 })
+     * const open = posts.filter(p => !p.isClosed)
+     */
+    fetchForumPosts(channelId: string, options?: FetchForumPostsOptions): Promise<NovaForumPost[]>;
+    /**
+     * Fetch server events and return them as `NovaServerEvent` wrappers.
      *
-     * // Wait for a button click with a timeout
-     * const i = await client.waitFor('interactionCreate', i => i.isButton(), 60_000)
+     * @example
+     * const upcoming = await client.fetchEvents('server-id', { upcoming: true })
+     * for (const event of upcoming) console.log(event.title)
      */
-    waitFor<K extends keyof NovaClientEvents>(event: K, filter?: (...args: Parameters<NovaClientEvents[K]>) => boolean, timeoutMs?: number): Promise<Parameters<NovaClientEvents[K]>[0]>;
+    fetchEvents(serverId: string, options?: FetchEventsOptions): Promise<NovaServerEvent[]>;
     /**
-     * Disconnect from the gateway and clean up.
+     * Fetch a single server event by ID and return it as a `NovaServerEvent` wrapper.
+     *
+     * @example
+     * const event = await client.fetchEvent('event-id')
+     * if (event.isUpcoming) await event.edit({ title: 'Updated!' })
      */
-    disconnect(): void;
+    fetchEvent(eventId: string): Promise<NovaServerEvent>;
     /**
-     * Send a message via the WebSocket gateway (lower latency than HTTP).
-     * Requires the `messages.write` scope.
+     * Fetch a user's public profile.
      *
      * @example
-     * client.wsSend('channel-id', 'Hello from the gateway!')
+     * const user = await client.fetchUserProfile('user-id')
+     * console.log(user.bio)
      */
-    wsSend(channelId: string, content: string): void;
+    fetchUserProfile(userId: string): Promise<UserProfile>;
     /**
-     * Start a typing indicator via WebSocket.
+     * Fetch the XP leaderboard for a server.
+     *
+     * @example
+     * const top = await client.fetchLeaderboard('server-id', 10)
+     * top.forEach(entry => console.log(`#${entry.rank} ${entry.user.username} — ${entry.xp} XP`))
      */
-    wsTypingStart(channelId: string): void;
+    fetchLeaderboard(serverId: string, limit?: number): Promise<LeaderboardEntry[]>;
     /**
-     * Stop a typing indicator via WebSocket.
+     * Fetch warnings in a server, optionally filtered by user.
+     *
+     * @example
+     * const warnings = await client.fetchWarnings('server-id', { userId: 'user-id' })
      */
-    wsTypingStop(channelId: string): void;
-    on<K extends keyof NovaClientEvents>(event: K, listener: NovaClientEvents[K]): this;
-    on(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    fetchWarnings(serverId: string, options?: FetchWarningsOptions): Promise<Warning[]>;
+    /**
+     * Fetch all automod rules for a server.
+     *
+     * @example
+     * const rules = await client.fetchAutoModRules('server-id')
+     */
+    fetchAutoModRules(serverId: string): Promise<AutoModRule[]>;
+    /**
+     * Fetch all channel categories for a server.
+     *
+     * @example
+     * const cats = await client.fetchCategories('server-id')
+     */
+    fetchCategories(serverId: string): Promise<ChannelCategory[]>;
+    /**
+     * Fetch soundboard clips for a server.
+     *
+     * @example
+     * const clips = await client.fetchSoundboard('server-id')
+     */
+    fetchSoundboard(serverId: string): Promise<SoundboardClip[]>;
+    /**
+     * Fetch statistics for a server (member count, message count, etc.).
+     *
+     * @example
+     * const stats = await client.fetchServerStats('server-id')
+     * console.log(`${stats.onlineCount}/${stats.memberCount} online`)
+     */
+    fetchServerStats(serverId: string): Promise<ServerStats>;
+    /**
+     * Bulk delete up to 100 messages in a channel.
+     * Requires the `messages.manage` scope.
+     *
+     * @example
+     * const result = await client.bulkDelete('channel-id', messageIds)
+     * console.log(`Deleted ${result.deleted} messages`)
+     */
+    bulkDelete(channelId: string, messageIds: string[]): Promise<BulkDeleteResult>;
+    /**
+     * Wait for a specific event to be emitted, optionally filtered.
+     * Rejects after `timeoutMs` (default 30 s) if the condition never fires.
+     *
+     * @example
+     * // Wait for any message in a specific channel
+     * const msg = await client.waitFor('messageCreate', m => m.channelId === channelId)
+     *
+     * // Wait for a button click with a timeout
+     * const i = await client.waitFor('interactionCreate', i => i.isButton(), 60_000)
+     */
+    waitFor<K extends keyof NovaClientEvents>(event: K, filter?: (...args: Parameters<NovaClientEvents[K]>) => boolean, timeoutMs?: number): Promise<Parameters<NovaClientEvents[K]>[0]>;
+    /**
+     * Wait for the next message matching an optional filter.
+     * Short for `waitFor('messageCreate', filter, timeoutMs)`.
+     *
+     * @example
+     * // Wait for any message in a specific channel
+     * const msg = await client.waitForMessage(
+     *   m => m.channelId === channelId && !m.isFromBot(),
+     *   30_000,
+     * )
+     * console.log(msg.content)
+     */
+    waitForMessage(filter?: (msg: NovaMessage) => boolean, timeoutMs?: number): Promise<NovaMessage>;
+    /**
+     * Wait for the next button-click interaction matching an optional filter.
+     * Short for `waitFor('interactionCreate', i => i.isButton() && filter(i), timeoutMs)`.
+     *
+     * @example
+     * // Wait for any button on a specific message
+     * const click = await client.waitForButton(
+     *   i => i.triggerMsgId === message.id,
+     *   60_000,
+     * )
+     * await click.reply('Button clicked!')
+     */
+    waitForButton(filter?: (i: NovaInteraction) => boolean, timeoutMs?: number): Promise<NovaInteraction>;
+    /**
+     * Wait for the next select-menu interaction matching an optional filter.
+     * Short for `waitFor('interactionCreate', i => i.isSelectMenu() && filter(i), timeoutMs)`.
+     *
+     * @example
+     * const pick = await client.waitForSelectMenu(
+     *   i => i.customId === 'colour_pick',
+     *   60_000,
+     * )
+     * await pick.reply(`You picked: ${pick.values.join(', ')}`)
+     */
+    waitForSelectMenu(filter?: (i: NovaInteraction) => boolean, timeoutMs?: number): Promise<NovaInteraction>;
+    /**
+     * Disconnect from the gateway and clean up.
+     */
+    disconnect(): void;
+    /**
+     * Send a message via the WebSocket gateway (lower latency than HTTP).
+     * Requires the `messages.write` scope.
+     *
+     * @example
+     * client.wsSend('channel-id', 'Hello from the gateway!')
+     */
+    wsSend(channelId: string, content: string): void;
+    /**
+     * Start a typing indicator via WebSocket.
+     */
+    wsTypingStart(channelId: string): void;
+    /**
+     * Stop a typing indicator via WebSocket.
+     */
+    wsTypingStop(channelId: string): void;
+    on<K extends keyof NovaClientEvents>(event: K, listener: NovaClientEvents[K]): this;
+    on(event: string | symbol, listener: (...args: unknown[]) => void): this;
     once<K extends keyof NovaClientEvents>(event: K, listener: NovaClientEvents[K]): this;
     once(event: string | symbol, listener: (...args: unknown[]) => void): this;
     off<K extends keyof NovaClientEvents>(event: K, listener: NovaClientEvents[K]): this;
@@ -3653,4 +4783,1114 @@ declare function countdown(target: Date | number | string): {
     total: number;
 };
 
-export { ActionRowBuilder, type Attachment, AuditLogAPI, type AuditLogAction, type AuditLogEntry, type BanEntry, type BotApplication, type BotEvent, type BotEventType, type BotModalDefinition, type BotModalField, type BotPermissionRecord, type BotStatus, type BotUser, ButtonBuilder, type ButtonStyle, type Channel, type ChannelType, ChannelsAPI, Collection, CommandsAPI, type ContextCommandDefinition, Cooldown, CooldownManager, type CreateChannelOptions, type DirectMessage, type EditChannelOptions, type EditMessageOptions, type Embed, EmbedBuilder, type EmbedField, type ExecuteWebhookOptions, type FetchAuditLogsOptions, type FetchChannelsOptions, type FetchMembersOptions, type FetchMessagesOptions, HttpClient, type Interaction, InteractionOptions, type InteractionType, InteractionsAPI, type Invite, type InviteCreateOptions, InvitesAPI, Logger, type Member, MembersAPI, type Message, MessageBuilder, type MessageComponent, MessagesAPI, ModalBuilder, NovaChannel, NovaClient, type NovaClientEvents, type NovaClientOptions, NovaInteraction, NovaInvite, NovaMember, NovaMessage, NovaRole, type NovaServer, NovaServerWrapper, NovaWebhook, Paginator, type PermissionKey, Permissions, PermissionsAPI, PermissionsBitfield, type PermissionsQueryOptions, type PermissionsResult, PollBuilder, type PollDefinition, type PollInteractionsOptions, type PollOption, type PrefixCommandDefinition, type Reaction, type ReactionDetail, ReactionsAPI, type RegisteredContextCommand, type RegisteredPrefixCommand, type RegisteredSlashCommand, type RespondInteractionOptions, type Role, type RoleCreateOptions, type RoleEditOptions, RolesAPI, SelectMenuBuilder, type SelectMenuOption, type SendMessageOptions, type ServerUpdateOptions, ServersAPI, type SingleMember, SlashCommandBuilder, type SlashCommandDefinition, type SlashCommandOption, SlashCommandOptionBuilder, TextInputBuilder, type TextInputStyle, type VoiceState, type Webhook, type WebhookCreateOptions, type WebhookEditOptions, WebhooksAPI, countdown, formatDuration, formatRelative, parseTimestamp, sleep, withTimeout };
+/**
+ * A rich wrapper around a raw `ChannelCategory` with convenience methods.
+ *
+ * Returned by `client.fetchCategories()` and `server.fetchCategories()`.
+ *
+ * @example
+ * const cats = await client.fetchCategories('server-id')
+ * const general = cats.find(c => c.name === 'General')
+ * if (general) await general.rename('Lounges')
+ */
+declare class NovaCategory implements ChannelCategory {
+    /** Unique category ID. */
+    readonly id: string;
+    /** Display name of the category. */
+    readonly name: string;
+    /** Sort position — lower numbers appear higher in the channel list. */
+    readonly position: number;
+    /** The server this category belongs to. */
+    readonly serverId: string;
+    /** When the category was created. */
+    readonly createdAt: string;
+    private readonly _categories;
+    constructor(raw: ChannelCategory, categories: CategoriesAPI);
+    /**
+     * Edit this category's name and/or position.
+     * Requires the `channels.manage` scope.
+     *
+     * @example
+     * await cat.edit({ name: 'Lounges', position: 0 })
+     */
+    edit(options: EditCategoryOptions): Promise<NovaCategory>;
+    /**
+     * Rename this category.
+     * Requires the `channels.manage` scope.
+     *
+     * @example
+     * await cat.rename('Lounges')
+     */
+    rename(name: string): Promise<NovaCategory>;
+    /**
+     * Move this category to a specific position.
+     * Requires the `channels.manage` scope.
+     *
+     * @example
+     * await cat.setPosition(0)
+     */
+    setPosition(position: number): Promise<NovaCategory>;
+    /**
+     * Delete this category.
+     * Requires the `channels.manage` scope.
+     *
+     * @example
+     * await cat.delete()
+     */
+    delete(): Promise<void>;
+    toJSON(): ChannelCategory;
+    toString(): string;
+}
+
+/**
+ * A fluent builder for creating forum posts.
+ *
+ * @example
+ * const post = new ForumPostBuilder()
+ *   .setTitle('Ideas Thread')
+ *   .setBody('Share your ideas for server improvements here!')
+ *   .addTag('ideas')
+ *   .addTag('discussion')
+ *   .build()
+ *
+ * await client.forum.create(channelId, post)
+ */
+declare class ForumPostBuilder {
+    private _title;
+    private _body;
+    private _tags;
+    /**
+     * Set the post title.
+     */
+    setTitle(title: string): this;
+    /**
+     * Set the post body / content.
+     */
+    setBody(body: string): this;
+    /**
+     * Add a tag to the post.
+     * Tags are used to categorise forum posts.
+     */
+    addTag(tag: string): this;
+    /**
+     * Set all tags at once, replacing any previously added tags.
+     */
+    setTags(tags: string[]): this;
+    /**
+     * Validate and return the final `CreateForumPostOptions` object.
+     *
+     * @throws {Error} if title or body is missing.
+     */
+    build(): CreateForumPostOptions;
+}
+
+/**
+ * A fluent builder for creating server events.
+ *
+ * @example
+ * const event = new EventBuilder()
+ *   .setTitle('Game Night')
+ *   .setDescription('Weekly gaming session — all welcome!')
+ *   .setStartAt(new Date('2025-08-01T20:00:00Z'))
+ *   .setEndAt(new Date('2025-08-01T23:00:00Z'))
+ *   .setLocation('Voice Channel: Gaming')
+ *   .build()
+ *
+ * await client.events.create(serverId, event)
+ */
+declare class EventBuilder {
+    private _title;
+    private _description;
+    private _imageUrl;
+    private _location;
+    private _startAt;
+    private _endAt;
+    private _channelId;
+    /** Set the event title (required). */
+    setTitle(title: string): this;
+    /** Set the event description. */
+    setDescription(description: string): this;
+    /** Set a banner/cover image URL for the event. */
+    setImage(url: string): this;
+    /** Set the physical or virtual location for the event. */
+    setLocation(location: string): this;
+    /** Set when the event starts. Accepts a Date or ISO string. */
+    setStartAt(date: Date | string): this;
+    /** Set when the event ends. Accepts a Date or ISO string. */
+    setEndAt(date: Date | string): this;
+    /** Link the event to a specific channel. */
+    setChannel(channelId: string): this;
+    /**
+     * Validate and return the final `CreateEventOptions` object.
+     *
+     * @throws {Error} if title or startAt is missing.
+     */
+    build(): CreateEventOptions;
+}
+
+/**
+ * Fluent builder for creating custom server roles.
+ *
+ * @example
+ * const role = await client.roles.create(serverId,
+ *   new RoleBuilder()
+ *     .setName('Moderator')
+ *     .setColor('#ff6b6b')
+ *     .setHoist(true)
+ *     .allowSendMessages()
+ *     .build()
+ * )
+ */
+declare class RoleBuilder {
+    private _name;
+    private _color;
+    private _hoist;
+    private _permissions;
+    /** Set the role's display name (required). */
+    setName(name: string): this;
+    /**
+     * Set the role's accent colour.
+     * @param color Hex string — e.g. `'#5865F2'` or `'5865F2'`
+     */
+    setColor(color: string): this;
+    /**
+     * Whether this role is shown separately in the member sidebar.
+     * Default: `true` when called without arguments.
+     */
+    setHoist(hoist?: boolean): this;
+    /** Set a specific permission key to true or false. */
+    addPermission(key: string, value?: boolean): this;
+    /** Replace all permission overrides at once. */
+    setPermissions(permissions: Record<string, boolean>): this;
+    /** Grant the `sendMessages` permission. */
+    allowSendMessages(): this;
+    /** Deny the `sendMessages` permission. */
+    denySendMessages(): this;
+    /** Grant the `addReactions` permission. */
+    allowAddReactions(): this;
+    /** Grant the `manageMessages` permission (delete/pin messages). */
+    allowManageMessages(): this;
+    /** Grant the `manageChannels` permission. */
+    allowManageChannels(): this;
+    /** Grant the `kickMembers` permission. */
+    allowKickMembers(): this;
+    /** Grant the `banMembers` permission. */
+    allowBanMembers(): this;
+    /** Grant the `manageServer` permission. */
+    allowManageServer(): this;
+    /** Grant the `manageRoles` permission. */
+    allowManageRoles(): this;
+    /**
+     * Validate and build the `RoleCreateOptions` object.
+     *
+     * @throws if name is not set.
+     */
+    build(): RoleCreateOptions;
+}
+
+/**
+ * Fluent builder for creating server channels.
+ *
+ * @example
+ * const channel = await client.channels.create(serverId,
+ *   new ChannelBuilder()
+ *     .setName('announcements')
+ *     .setType('ANNOUNCEMENT')
+ *     .setTopic('Official announcements only')
+ *     .build()
+ * )
+ */
+declare class ChannelBuilder {
+    private _name;
+    private _type;
+    private _topic;
+    private _position;
+    private _categoryId;
+    private _slowMode;
+    private _isPrivate;
+    /** Set the channel name (required). No # prefix needed. */
+    setName(name: string): this;
+    /**
+     * Set the channel type.
+     * @default 'TEXT'
+     */
+    setType(type: ChannelType): this;
+    /** Create a TEXT channel. */
+    asText(): this;
+    /** Create a VOICE channel. */
+    asVoice(): this;
+    /** Create an ANNOUNCEMENT channel. */
+    asAnnouncement(): this;
+    /** Create a FORUM channel. */
+    asForum(): this;
+    /** Create a STAGE channel. */
+    asStage(): this;
+    /** Set the channel topic / description. */
+    setTopic(topic: string): this;
+    /** Set the channel's sort position. */
+    setPosition(position: number): this;
+    /** Place the channel inside an existing category by its ID. */
+    setCategory(categoryId: string): this;
+    /**
+     * Set a slow-mode interval in seconds.
+     * Members must wait this long between messages.
+     * Pass `0` to disable.
+     */
+    setSlowMode(seconds: number): this;
+    /**
+     * Mark the channel as private.
+     * Private channels are only visible to members with explicit access.
+     */
+    setPrivate(isPrivate?: boolean): this;
+    /**
+     * Validate and build the `CreateChannelOptions` object.
+     *
+     * @throws if name is not set.
+     */
+    build(): CreateChannelOptions;
+}
+
+/**
+ * Fluent builder for creating server invites.
+ *
+ * @example
+ * // A one-time use invite expiring in 24 hours
+ * const invite = await client.invites.create(serverId,
+ *   new InviteBuilder()
+ *     .setOneTimeUse()
+ *     .expiresIn(24 * 60 * 60 * 1000)
+ *     .build()
+ * )
+ * console.log(`https://novachatapp.com/invite/${invite.code}`)
+ *
+ * // Permanent invite with no restrictions
+ * const perm = await client.invites.create(serverId,
+ *   new InviteBuilder().setPermanent().build()
+ * )
+ */
+declare class InviteBuilder {
+    private _maxUses;
+    private _expiresAt;
+    /**
+     * Set the maximum number of times this invite can be used.
+     * Pass `null` for unlimited uses.
+     */
+    setMaxUses(maxUses: number | null): this;
+    /**
+     * Set an absolute expiry date/time for this invite.
+     * Pass a `Date`, an ISO string, or `null` to never expire.
+     */
+    setExpiresAt(date: Date | string | null): this;
+    /**
+     * Set expiry as a duration from now.
+     * @param ms  Duration in milliseconds.
+     *
+     * @example
+     * builder.expiresIn(7 * 24 * 60 * 60 * 1000) // 7 days
+     */
+    expiresIn(ms: number): this;
+    /**
+     * Create a one-time use invite (`maxUses = 1`).
+     */
+    setOneTimeUse(): this;
+    /**
+     * Create a permanent invite with no expiry or usage limit.
+     */
+    setPermanent(): this;
+    /**
+     * Build the `InviteCreateOptions` object.
+     */
+    build(): InviteCreateOptions;
+}
+
+type AutoModRuleType = 'BLOCKED_WORD' | 'BLOCKED_LINK';
+/**
+ * Fluent builder for AutoMod rules.
+ *
+ * @example
+ * // Block a specific word
+ * await client.automod.create(serverId,
+ *   new AutoModRuleBuilder()
+ *     .blockWord('badword')
+ *     .build()
+ * )
+ *
+ * // Block a domain
+ * await client.automod.create(serverId,
+ *   new AutoModRuleBuilder()
+ *     .blockLink('spam.example.com')
+ *     .build()
+ * )
+ *
+ * // Create a rule in disabled state
+ * await client.automod.create(serverId,
+ *   new AutoModRuleBuilder()
+ *     .setType('BLOCKED_WORD')
+ *     .setValue('draft-word')
+ *     .setEnabled(false)
+ *     .build()
+ * )
+ */
+declare class AutoModRuleBuilder {
+    private _type;
+    private _value;
+    private _enabled;
+    /** Set the rule type explicitly. */
+    setType(type: AutoModRuleType): this;
+    /**
+     * Set the blocked value (word or domain).
+     */
+    setValue(value: string): this;
+    /**
+     * Shorthand: set type to BLOCKED_WORD and optionally set the value.
+     *
+     * @example
+     * builder.blockWord('badword')
+     */
+    blockWord(word?: string): this;
+    /**
+     * Shorthand: set type to BLOCKED_LINK and optionally set the domain.
+     *
+     * @example
+     * builder.blockLink('spam.com')
+     */
+    blockLink(domain?: string): this;
+    /**
+     * Whether the rule is active immediately.
+     * @default true
+     */
+    setEnabled(enabled: boolean): this;
+    /**
+     * Validate and build the `CreateAutoModRuleOptions` object.
+     *
+     * @throws if type or value is not set.
+     */
+    build(): CreateAutoModRuleOptions;
+}
+
+/**
+ * Fluent builder for context-menu commands.
+ *
+ * Context-menu commands appear when a user right-clicks (or long-presses) a
+ * **message** or a **user** in the Nova client.  There are two target types:
+ * - `'MESSAGE'` — appears in the message context menu.
+ * - `'USER'`    — appears in the user context menu.
+ *
+ * @example
+ * // Register a "Report Message" context-menu command globally
+ * await client.commands.setContext([
+ *   new ContextMenuCommandBuilder()
+ *     .setName('Report Message')
+ *     .forMessages()
+ *     .build(),
+ * ])
+ *
+ * // Handle the interaction
+ * client.on('interactionCreate', async (i) => {
+ *   if (i.type === 'CONTEXT_MENU' && i.commandName === 'Report Message') {
+ *     const targetMsgId = i.contextTargetId
+ *     await i.replyEphemeral(`Message ${targetMsgId} has been reported.`)
+ *   }
+ * })
+ */
+declare class ContextMenuCommandBuilder {
+    private _name;
+    private _target;
+    private _guildId;
+    /**
+     * Display name of the command (shown in the context menu).
+     * Max 32 characters. May contain spaces.
+     *
+     * @example
+     * builder.setName('Report Message')
+     */
+    setName(name: string): this;
+    /**
+     * Set whether the command targets messages or users.
+     *
+     * @example
+     * builder.setTarget('USER')
+     */
+    setTarget(target: 'MESSAGE' | 'USER'): this;
+    /**
+     * Shorthand for `setTarget('MESSAGE')`.
+     *
+     * @example
+     * builder.forMessages()
+     */
+    forMessages(): this;
+    /**
+     * Shorthand for `setTarget('USER')`.
+     *
+     * @example
+     * builder.forUsers()
+     */
+    forUsers(): this;
+    /**
+     * Register this command only for a specific server (guild).
+     * Omit (or pass `null`) to make the command available globally.
+     *
+     * @example
+     * builder.setGuildId('server-id')
+     */
+    setGuildId(guildId: string | null): this;
+    /**
+     * Validate and return the final command definition object.
+     * Throws if `name` has not been set.
+     */
+    build(): ContextCommandDefinition;
+    /** Alias for `build()`. */
+    toJSON(): ContextCommandDefinition;
+}
+
+interface MessageCollectorOptions {
+    /**
+     * How many messages to collect before resolving automatically.
+     * @default 1
+     */
+    count?: number;
+    /**
+     * Time in ms before the collector stops, even if `count` was not reached.
+     * @default 60_000
+     */
+    timeout?: number;
+    /**
+     * Custom filter — return `true` to include a message.
+     * Messages that do not pass are silently ignored.
+     */
+    filter?: (message: NovaMessage) => boolean;
+}
+/**
+ * Collects multiple messages matching a filter.
+ * Resolves once `count` messages are collected **or** the timeout elapses.
+ * The resolved array may be shorter than `count` if the timeout fires first.
+ *
+ * @example
+ * // Collect 3 non-bot messages from a specific channel within 30 s
+ * const messages = await new MessageCollector(client, {
+ *   filter: msg => msg.channelId === channelId && !msg.isFromBot(),
+ *   count: 3,
+ *   timeout: 30_000,
+ * }).run()
+ *
+ * for (const msg of messages) {
+ *   console.log(msg.author.displayName, ':', msg.content)
+ * }
+ */
+declare class MessageCollector {
+    private readonly _emitter;
+    private readonly _options;
+    constructor(emitter: EventEmitter$1, options?: MessageCollectorOptions);
+    /**
+     * Start collecting messages.
+     * Returns a promise that resolves with the collected `NovaMessage` array.
+     */
+    run(): Promise<NovaMessage[]>;
+}
+
+type InteractionFilter = (interaction: NovaInteraction) => boolean;
+interface InteractionCollectorOptions {
+    /**
+     * How many interactions to collect before resolving.
+     * @default 1
+     */
+    count?: number;
+    /**
+     * Time in ms before the collector stops.
+     * @default 60_000
+     */
+    timeout?: number;
+    /**
+     * Only collect interactions triggered on this message.
+     * Useful for button/select-menu rows attached to a specific message.
+     */
+    messageId?: string;
+    /**
+     * Custom filter function — return `true` to include an interaction.
+     */
+    filter?: InteractionFilter;
+}
+/**
+ * Collects interactions (button clicks, select-menu choices) matching a filter.
+ * Resolves once `count` interactions are collected **or** the timeout elapses.
+ *
+ * @example
+ * // Send a message with buttons, then await a click from the same user
+ * const msg = await channel.send({
+ *   content: 'Pick an option:',
+ *   components: row.toJSON(),
+ * })
+ *
+ * const [interaction] = await new InteractionCollector(client, {
+ *   messageId: msg.id,
+ *   filter: i => i.isButton() && i.userId === authorId,
+ *   timeout: 30_000,
+ * }).run()
+ *
+ * if (interaction) await interaction.reply('You clicked: ' + interaction.customId)
+ *
+ * @example
+ * // Collect any 3 button clicks on a poll message
+ * const votes = await new InteractionCollector(client, {
+ *   messageId: pollMsgId,
+ *   filter: i => i.isButton(),
+ *   count: 3,
+ * }).run()
+ */
+declare class InteractionCollector {
+    private readonly _emitter;
+    private readonly _options;
+    constructor(emitter: EventEmitter$1, options?: InteractionCollectorOptions);
+    /**
+     * Start collecting interactions.
+     * Returns a promise that resolves with the collected `NovaInteraction` array.
+     */
+    run(): Promise<NovaInteraction[]>;
+}
+
+/**
+ * Utilities for parsing mentions, emojis, and special tokens out of
+ * Nova message content strings.
+ *
+ * @example
+ * const content = 'Hello <@user123>! Check out <#channel456>.'
+ *
+ * MentionParser.userIds(content)    // ['user123']
+ * MentionParser.channelIds(content) // ['channel456']
+ *
+ * // Format a mention
+ * MentionParser.user('user123')     // '<@user123>'
+ * MentionParser.channel('ch456')    // '<#ch456>'
+ *
+ * // Clean the string
+ * MentionParser.stripMentions(content)
+ * // 'Hello ! Check out .'
+ */
+declare class MentionParser {
+    /**
+     * Extract all user IDs mentioned in the content (`<@userId>`).
+     *
+     * @example
+     * MentionParser.userIds('Hello <@abc> and <@xyz>!') // ['abc', 'xyz']
+     */
+    static userIds(content: string): string[];
+    /**
+     * Extract all channel IDs mentioned in the content (`<#channelId>`).
+     *
+     * @example
+     * MentionParser.channelIds('Go to <#general>!') // ['general']
+     */
+    static channelIds(content: string): string[];
+    /**
+     * Extract all role IDs mentioned in the content (`<&roleId>`).
+     *
+     * @example
+     * MentionParser.roleIds('Paging <&mods>!') // ['mods']
+     */
+    static roleIds(content: string): string[];
+    /**
+     * Extract all custom emoji IDs mentioned in the content (`<:name:id>`).
+     *
+     * @example
+     * MentionParser.emojiIds('Love it <:nova:12345>!')
+     * // [{ name: 'nova', id: '12345' }]
+     */
+    static emojiIds(content: string): Array<{
+        name: string;
+        id: string;
+    }>;
+    /**
+     * Format a user ID into a mention string `<@userId>`.
+     *
+     * @example
+     * MentionParser.user('abc123') // '<@abc123>'
+     */
+    static user(userId: string): string;
+    /**
+     * Format a channel ID into a mention string `<#channelId>`.
+     *
+     * @example
+     * MentionParser.channel('general') // '<#general>'
+     */
+    static channel(channelId: string): string;
+    /**
+     * Format a role ID into a mention string `<&roleId>`.
+     *
+     * @example
+     * MentionParser.role('mods') // '<&mods>'
+     */
+    static role(roleId: string): string;
+    /**
+     * Format a custom emoji mention `<:name:id>`.
+     *
+     * @example
+     * MentionParser.emoji('nova', '12345') // '<:nova:12345>'
+     */
+    static emoji(name: string, id: string): string;
+    /**
+     * Remove all mention tokens from `content` and return the cleaned string.
+     *
+     * @example
+     * MentionParser.stripMentions('Hello <@u1> in <#c1>!')
+     * // 'Hello  in !'
+     */
+    static stripMentions(content: string): string;
+    /**
+     * Returns `true` if `content` mentions at least one user.
+     * Optionally checks for a specific `userId`.
+     *
+     * @example
+     * MentionParser.hasMention('Hi <@u1>')           // true
+     * MentionParser.hasMention('Hi <@u1>', 'u1')     // true
+     * MentionParser.hasMention('Hi <@u1>', 'u2')     // false
+     */
+    static hasMention(content: string, userId?: string): boolean;
+    /**
+     * Returns `true` if `content` mentions a specific bot by its ID.
+     *
+     * @example
+     * if (MentionParser.mentionsBotId(message.content, client.user.id)) {
+     *   await message.reply('You called?')
+     * }
+     */
+    static mentionsBotId(content: string, botId: string): boolean;
+}
+
+interface EmbedPaginatorOptions<T> {
+    /** Items to paginate. */
+    items: T[];
+    /**
+     * Number of items per page.
+     * @default 10
+     */
+    pageSize?: number;
+    /** ID of the channel to send the paginator into. */
+    channelId: string;
+    /**
+     * Produce an embed for the given page slice.
+     * Called every time the page changes.
+     *
+     * @param page        - Items for this page.
+     * @param pageIndex   - Zero-based page index.
+     * @param totalPages  - Total number of pages.
+     */
+    renderPage(page: T[], pageIndex: number, totalPages: number): Embed;
+    /**
+     * If set, only this user ID is allowed to navigate the pages.
+     * Other users clicking the buttons are silently ignored.
+     */
+    userId?: string;
+    /**
+     * How long (ms) to keep listening for button clicks before giving up.
+     * @default 60_000
+     */
+    timeout?: number;
+    /**
+     * Append "Page X / Y" to the embed footer automatically.
+     * @default true
+     */
+    showPageCounter?: boolean;
+}
+/**
+ * Send a paginated embed that users can step through with ◀ ▶ buttons.
+ *
+ * @example
+ * const paginator = new EmbedPaginator(client, client.messages, client.interactions, {
+ *   channelId: 'channel-id',
+ *   items: leaderboard,
+ *   pageSize: 5,
+ *   renderPage(page, idx, total) {
+ *     return new EmbedBuilder()
+ *       .setTitle('🏆 Leaderboard')
+ *       .setDescription(
+ *         page
+ *           .map((e, i) => `**${idx * 5 + i + 1}.** ${e.user.displayName} — ${e.xp} XP`)
+ *           .join('\n'),
+ *       )
+ *       .toJSON()
+ *   },
+ * })
+ * await paginator.send()
+ */
+declare class EmbedPaginator<T> {
+    private readonly emitter;
+    private readonly messages;
+    private readonly interactions;
+    private readonly options;
+    private page;
+    private readonly pages;
+    constructor(emitter: EventEmitter$1, messages: MessagesAPI, interactions: InteractionsAPI, options: EmbedPaginatorOptions<T>);
+    /** Total number of pages. */
+    get totalPages(): number;
+    /**
+     * Send the first page to the configured channel.
+     * If there are multiple pages, attaches ◀ ▶ navigation buttons and
+     * listens for clicks for up to `options.timeout` ms.
+     */
+    send(): Promise<void>;
+    private _awaitClick;
+    private _buildPayload;
+}
+
+interface ConfirmationDialogOptions {
+    /** Channel to send the prompt into. */
+    channelId: string;
+    /**
+     * Text shown above the confirm / cancel buttons.
+     * @default 'Are you sure?'
+     */
+    content?: string;
+    /**
+     * Label for the confirm button.
+     * @default 'Confirm'
+     */
+    confirmLabel?: string;
+    /**
+     * Label for the cancel button.
+     * @default 'Cancel'
+     */
+    cancelLabel?: string;
+    /**
+     * If set, only this user ID's response is accepted.
+     * Other users clicking are silently ignored.
+     */
+    userId?: string;
+    /**
+     * How long (ms) to wait before treating the prompt as cancelled.
+     * @default 30_000
+     */
+    timeout?: number;
+}
+/**
+ * Send a yes / no confirmation prompt and wait for the user's response.
+ * Returns `true` if confirmed, `false` if cancelled or timed out.
+ *
+ * @example
+ * const dialog = new ConfirmationDialog(client, client.messages, client.interactions)
+ *
+ * const confirmed = await dialog.ask({
+ *   channelId: interaction.channelId,
+ *   content: `Are you sure you want to ban **${target.displayName}**?`,
+ *   userId: interaction.userId,
+ * })
+ *
+ * if (confirmed) {
+ *   await client.members.ban(serverId, target.userId, 'Confirmed via bot')
+ *   await interaction.reply('User has been banned.')
+ * } else {
+ *   await interaction.reply('Cancelled.')
+ * }
+ */
+declare class ConfirmationDialog {
+    private readonly emitter;
+    private readonly messages;
+    private readonly interactions;
+    constructor(emitter: EventEmitter$1, messages: MessagesAPI, interactions: InteractionsAPI);
+    /**
+     * Send the confirmation prompt and await the user's choice.
+     * Returns `true` for confirm, `false` for cancel or timeout.
+     */
+    ask(options: ConfirmationDialogOptions): Promise<boolean>;
+    private _awaitClick;
+}
+
+/**
+ * Parser for prefix-command message content.
+ *
+ * Handles both positional arguments and named flags:
+ * - `--flag value`    → string flag
+ * - `--flag "multi word value"` → quoted string flag
+ * - `--flag`          → boolean flag  (value = 'true')
+ * - `-f`              → single-char shorthand boolean flag
+ * - bare tokens       → positional args (in order)
+ *
+ * @example
+ * // Input: !ban @nick123 7 --reason "rule violation" --notify
+ * // After stripping the @mention: "nick123 7 --reason "rule violation" --notify"
+ *
+ * const args = ArgumentParser.parse('nick123 7 --reason "rule violation" --notify')
+ *
+ * args.positional        // ['nick123', '7']
+ * args.get('reason')     // 'rule violation'
+ * args.has('notify')     // true
+ * args.getInt(1)         // 7
+ */
+declare class ParsedArguments {
+    /** Positional (non-flag) arguments in order. */
+    readonly positional: string[];
+    private readonly _flags;
+    constructor(positional: string[], flags: Map<string, string>);
+    /**
+     * Whether a named flag is present (regardless of value).
+     *
+     * @example
+     * args.has('notify') // true for --notify or --notify true
+     */
+    has(flag: string): boolean;
+    /**
+     * Get the string value of a named flag, or `null` if absent.
+     *
+     * @example
+     * args.get('reason') // 'rule violation'
+     */
+    get(flag: string): string | null;
+    /**
+     * Get the string value of a named flag, throwing if missing.
+     *
+     * @example
+     * const reason = args.require('reason') // throws if --reason not supplied
+     */
+    require(flag: string): string;
+    /**
+     * Parse the flag value as an integer, or `null` if absent / not a number.
+     *
+     * @example
+     * args.getInt('days') // 7 from '--days 7'
+     */
+    getInt(flag: string): number | null;
+    /**
+     * Parse the flag value as a float, or `null` if absent / not a number.
+     */
+    getFloat(flag: string): number | null;
+    /**
+     * Get a positional argument by index (0-based), or `null` if absent.
+     *
+     * @example
+     * args.at(0) // first positional token
+     */
+    at(index: number): string | null;
+    /**
+     * Get positional argument at `index` as an integer, or `null`.
+     *
+     * @example
+     * args.getInt(1) // 7 when positional is ['nick123', '7']
+     */
+    getIntAt(index: number): number | null;
+    /**
+     * All flag names that were parsed.
+     *
+     * @example
+     * args.flags() // ['reason', 'notify']
+     */
+    flags(): string[];
+    toJSON(): {
+        positional: string[];
+        flags: {
+            [k: string]: string;
+        };
+    };
+}
+/**
+ * Parse the content of a prefix-command message into positional args + named flags.
+ *
+ * @example
+ * const args = ArgumentParser.parse('user123 --reason "rule break" --silent')
+ * args.at(0)           // 'user123'
+ * args.get('reason')   // 'rule break'
+ * args.has('silent')   // true
+ *
+ * // Strip the command prefix before parsing:
+ * const content = msg.content.slice('!kick '.length).trim()
+ * const args = ArgumentParser.parse(content)
+ */
+declare class ArgumentParser {
+    /**
+     * Parse a raw string of arguments.
+     * Returns a `ParsedArguments` instance.
+     */
+    static parse(input: string): ParsedArguments;
+    /**
+     * Strip a user mention like `<@123456>` from the start of the input string
+     * and return the remainder trimmed. Returns the original string unchanged if
+     * no leading mention is found.
+     *
+     * @example
+     * ArgumentParser.stripMention('<@98765> hello world') // 'hello world'
+     */
+    static stripMention(input: string): string;
+    /**
+     * Split `input` into tokens. Quoted strings are treated as single tokens.
+     */
+    private static _tokenise;
+}
+
+/**
+ * A simple in-memory key-value cache with optional per-entry TTL.
+ * Expired entries are evicted lazily (on read) and eagerly (via `prune()`).
+ *
+ * @typeParam K - Key type (default: `string`).
+ * @typeParam V - Value type.
+ *
+ * @example
+ * const cache = new CacheMap<string, UserProfile>()
+ *
+ * // Cache a profile for 5 minutes
+ * cache.set(userId, profile, 5 * 60_000)
+ *
+ * // Retrieve it later
+ * const cached = cache.get(userId)
+ * if (cached) {
+ *   console.log('cache hit:', cached.displayName)
+ * } else {
+ *   // Fetch fresh, then cache
+ *   const fresh = await client.fetchUserProfile(userId)
+ *   cache.set(userId, fresh, 5 * 60_000)
+ * }
+ */
+declare class CacheMap<K = string, V = unknown> {
+    private readonly _store;
+    /**
+     * Store a value.
+     *
+     * @param key   - Cache key.
+     * @param value - Value to store.
+     * @param ttlMs - Optional time-to-live in milliseconds. Omit for permanent storage.
+     */
+    set(key: K, value: V, ttlMs?: number): this;
+    /**
+     * Retrieve a value, or `undefined` if absent or expired.
+     * Expired entries are automatically deleted on access.
+     */
+    get(key: K): V | undefined;
+    /**
+     * Check if a live (non-expired) entry exists for this key.
+     */
+    has(key: K): boolean;
+    /**
+     * Delete an entry.
+     * Returns `true` if the entry existed (even if it was expired).
+     */
+    delete(key: K): boolean;
+    /** Remove all entries. */
+    clear(): void;
+    /**
+     * Number of **live** (non-expired) entries.
+     * This prunes expired entries as a side-effect.
+     */
+    get size(): number;
+    /**
+     * Remove all expired entries immediately.
+     * Useful to call occasionally to free memory.
+     *
+     * @example
+     * // Prune every 10 minutes
+     * setInterval(() => cache.prune(), 10 * 60_000)
+     */
+    prune(): number;
+    /**
+     * Return all **live** keys.
+     */
+    keys(): K[];
+    /**
+     * Return all **live** values.
+     */
+    values(): V[];
+    /**
+     * Return all **live** `[key, value]` pairs.
+     */
+    entries(): [K, V][];
+    /**
+     * Get a value or compute & cache it if missing.
+     * Very useful for "cache-aside" data loading.
+     *
+     * @param key    - Cache key.
+     * @param loader - Async function that produces the value when the cache is cold.
+     * @param ttlMs  - Optional TTL to apply to the newly cached value.
+     *
+     * @example
+     * const profile = await cache.getOrSet(userId, () => client.fetchUserProfile(userId), 60_000)
+     */
+    getOrSet(key: K, loader: () => Promise<V>, ttlMs?: number): Promise<V>;
+    /**
+     * Return the number of milliseconds until a key expires.
+     * Returns `null` if the key has no TTL, `0` if it is already expired.
+     */
+    ttl(key: K): number | null;
+    [Symbol.iterator](): Iterator<[K, V]>;
+}
+
+type TaskId = string;
+/**
+ * Lightweight task scheduler for bots.
+ * Supports one-shot delays, absolute-time scheduling, and recurring intervals.
+ * All registered tasks can be cancelled individually or all at once.
+ *
+ * @example
+ * const scheduler = new EventScheduler()
+ *
+ * // Run once after 10 seconds
+ * scheduler.schedule(10_000, async () => {
+ *   await client.messages.send(channelId, { content: 'Reminder: meeting in 5 minutes!' })
+ * })
+ *
+ * // Run every hour
+ * scheduler.repeat(60 * 60_000, async () => {
+ *   const stats = await client.fetchServerStats(serverId)
+ *   console.log(`${stats.onlineCount} online`)
+ * })
+ *
+ * // Cancel everything when the bot shuts down
+ * client.once('disconnect', () => scheduler.cancelAll())
+ */
+declare class EventScheduler {
+    private readonly _tasks;
+    /**
+     * Schedule a one-shot task to run after `delayMs` milliseconds.
+     * Returns a task ID that can be passed to `cancel()`.
+     *
+     * @example
+     * const id = scheduler.schedule(5_000, () => console.log('5 seconds later'))
+     * // Change your mind:
+     * scheduler.cancel(id)
+     */
+    schedule(delayMs: number, fn: () => unknown): TaskId;
+    /**
+     * Schedule a one-shot task to run at a specific `Date`.
+     * If the date is in the past, the callback fires on the next event-loop tick.
+     *
+     * @example
+     * const nextMidnight = new Date()
+     * nextMidnight.setHours(24, 0, 0, 0)
+     * scheduler.scheduleAt(nextMidnight, () => console.log('Midnight!'))
+     */
+    scheduleAt(date: Date, fn: () => unknown): TaskId;
+    /**
+     * Schedule a recurring task that fires every `intervalMs` milliseconds.
+     * Returns a task ID that can be passed to `cancel()`.
+     *
+     * @example
+     * // Check incoming messages every minute
+     * const id = scheduler.repeat(60_000, () => checkForAnnouncements())
+     */
+    repeat(intervalMs: number, fn: () => unknown): TaskId;
+    /**
+     * Cancel a previously scheduled task by its ID.
+     * Returns `true` if the task existed, `false` if it had already fired or
+     * was not found.
+     *
+     * @example
+     * const id = scheduler.schedule(30_000, doSomething)
+     * // …maybe cancel it:
+     * scheduler.cancel(id)
+     */
+    cancel(id: TaskId): boolean;
+    /**
+     * Cancel all pending tasks.
+     * Useful during graceful shutdown.
+     *
+     * @example
+     * client.once('disconnect', () => scheduler.cancelAll())
+     */
+    cancelAll(): void;
+    /**
+     * Number of currently active (pending or recurring) tasks.
+     */
+    get pendingCount(): number;
+    /**
+     * IDs of all currently registered tasks.
+     */
+    taskIds(): TaskId[];
+    private _run;
+}
+
+export { ActionRowBuilder, ArgumentParser, type Attachment, AuditLogAPI, type AuditLogAction, type AuditLogEntry, AutoModAPI, type AutoModRule, AutoModRuleBuilder, type AutoModRuleType$1 as AutoModRuleType, type BanEntry, type BotApplication, type BotEvent, type BotEventType, type BotModalDefinition, type BotModalField, type BotPermissionRecord, type BotStatus, type BotUser, type BulkDeleteResult, ButtonBuilder, type ButtonStyle, CacheMap, CategoriesAPI, type Channel, ChannelBuilder, type ChannelCategory, type ChannelType, ChannelsAPI, Collection, CommandsAPI, ConfirmationDialog, type ConfirmationDialogOptions, type ContextCommandDefinition, ContextMenuCommandBuilder, Cooldown, CooldownManager, type CreateAutoModRuleOptions, type CreateCategoryOptions, type CreateChannelOptions, type CreateEventOptions, type CreateForumPostOptions, type DirectMessage, type EditAutoModRuleOptions, type EditCategoryOptions, type EditChannelOptions, type EditEventOptions, type EditForumPostOptions, type EditMessageOptions, type Embed, EmbedBuilder, type EmbedField, EmbedPaginator, type EmbedPaginatorOptions, EventBuilder, EventScheduler, EventsAPI, type ExecuteWebhookOptions, type FetchAuditLogsOptions, type FetchChannelsOptions, type FetchEventsOptions, type FetchForumPostsOptions, type FetchMembersOptions, type FetchMessagesOptions, type FetchWarningsOptions, ForumAPI, type ForumPost, ForumPostBuilder, HttpClient, type Interaction, InteractionCollector, type InteractionCollectorOptions, type InteractionFilter, InteractionOptions, type InteractionType, InteractionsAPI, type Invite, InviteBuilder, type InviteCreateOptions, InvitesAPI, type LeaderboardEntry, Logger, type Member, type MemberXPData, MembersAPI, MentionParser, type Message, MessageBuilder, MessageCollector, type MessageCollectorOptions, type MessageComponent, MessagesAPI, ModalBuilder, NovaBan, NovaCategory, NovaChannel, NovaClient, type NovaClientEvents, type NovaClientOptions, NovaForumPost, NovaInteraction, NovaInvite, NovaMember, NovaMessage, NovaRole, type NovaServer, NovaServerEvent, NovaServerWrapper, NovaWarning, NovaWebhook, Paginator, ParsedArguments, type PermissionKey, Permissions, PermissionsAPI, PermissionsBitfield, type PermissionsQueryOptions, type PermissionsResult, PollBuilder, type PollDefinition, type PollInteractionsOptions, type PollOption, type PrefixCommandDefinition, type Reaction, type ReactionDetail, ReactionsAPI, type RegisteredContextCommand, type RegisteredPrefixCommand, type RegisteredSlashCommand, type RespondInteractionOptions, type Role, RoleBuilder, type RoleCreateOptions, type RoleEditOptions, RolesAPI, SelectMenuBuilder, type SelectMenuOption, type SendMessageOptions, type ServerEvent, type ServerEventAttendee, type ServerStats, type ServerUpdateOptions, ServersAPI, type SingleMember, SlashCommandBuilder, type SlashCommandDefinition, type SlashCommandOption, SlashCommandOptionBuilder, type SoundboardClip, TextInputBuilder, type TextInputStyle, type UserProfile, UsersAPI, type VoiceState, type Warning, type Webhook, type WebhookCreateOptions, type WebhookEditOptions, WebhooksAPI, countdown, formatDuration, formatRelative, parseTimestamp, sleep, withTimeout };