novaapp-sdk 1.4.0 → 1.4.2

package/dist/client-DbKa6yJo.d.mts

@@ -0,0 +1,4244 @@
+import { EventEmitter } from 'node:events';
+
+/**
+ * Lightweight HTTP client for the Nova Bot API.
+ * Uses the native fetch API (Node 18+).
+ */
+declare class HttpClient {
+    readonly baseUrl: string;
+    private readonly token;
+    constructor(baseUrl: string, token: string);
+    private request;
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    patch<T>(path: string, body?: unknown): Promise<T>;
+    delete<T>(path: string): Promise<T>;
+}
+
+interface BotUser {
+    id: string;
+    username: string;
+    displayName: string;
+    avatar: string | null;
+    isBot: true;
+}
+interface BotApplication {
+    id: string;
+    name: string;
+    /** Convenience: same as botUser.username */
+    username: string;
+    /** Convenience: same as botUser.displayName */
+    displayName: string;
+    description: string | null;
+    avatar: string | null;
+    category: string | null;
+    isPublic: boolean;
+    isVerified: boolean;
+    callbackUrl: string | null;
+    createdAt: string;
+    botUser: BotUser;
+    scopes: string[];
+}
+interface NovaServer {
+    id: string;
+    name: string;
+    icon: string | null;
+    description: string | null;
+    memberCount: number;
+    channelCount: number;
+    joinedAt: string;
+}
+interface Member {
+    role: 'OWNER' | 'ADMIN' | 'MEMBER';
+    joinedAt: string;
+    user: {
+        id: string;
+        username: string;
+        displayName: string;
+        avatar: string | null;
+        status: 'ONLINE' | 'IDLE' | 'DND' | 'OFFLINE';
+        isBot: boolean;
+    };
+}
+type ChannelType = 'TEXT' | 'VOICE' | 'ANNOUNCEMENT' | 'FORUM' | 'STAGE';
+interface Channel {
+    id: string;
+    name: string;
+    type: ChannelType;
+    serverId: string | null;
+    topic: string | null;
+    position: number;
+    /** Slow-mode interval in seconds. `0` means disabled. */
+    slowMode: number;
+    createdAt: string;
+}
+interface Role {
+    id: string;
+    name: string;
+    color: string | null;
+    position: number;
+    serverId: string;
+    hoist: boolean;
+    permissions: Record<string, boolean>;
+    createdAt: string;
+}
+interface BanEntry {
+    userId: string;
+    username: string;
+    displayName: string;
+    avatar: string | null;
+    reason: string | null;
+    bannedAt: string;
+    moderatorId: string | null;
+}
+interface Invite {
+    code: string;
+    serverId: string;
+    creatorId: string;
+    uses: number;
+    maxUses: number | null;
+    expiresAt: string | null;
+    createdAt: string;
+}
+/** A message with all reaction data fetched. */
+interface ReactionDetail {
+    emoji: string;
+    count: number;
+    users: Array<{
+        id: string;
+        username: string;
+        displayName: string;
+        avatar: string | null;
+    }>;
+}
+/** Bot status that can be set via `client.setStatus()`. */
+type BotStatus = 'ONLINE' | 'IDLE' | 'DND' | 'OFFLINE';
+interface Attachment {
+    id: string;
+    url: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+}
+interface Reaction {
+    emoji: string;
+    count: number;
+    userIds: string[];
+}
+interface EmbedField {
+    name: string;
+    value: string;
+    inline?: boolean;
+}
+interface Embed {
+    title?: string;
+    description?: string;
+    /** Makes the title a clickable link. */
+    url?: string;
+    /** Hex colour string — e.g. `'#5865F2'`. */
+    color?: string;
+    thumbnail?: string;
+    image?: string;
+    footer?: string;
+    fields?: EmbedField[];
+    timestamp?: string;
+    author?: {
+        name: string;
+        iconUrl?: string;
+    };
+}
+interface MessageComponent {
+    type: 'button' | 'select';
+    customId?: string;
+    label?: string;
+    style?: 'primary' | 'secondary' | 'success' | 'danger' | 'link';
+    emoji?: string;
+    url?: string;
+    placeholder?: string;
+    options?: Array<{
+        label: string;
+        value: string;
+        description?: string;
+    }>;
+    minValues?: number;
+    maxValues?: number;
+    disabled?: boolean;
+}
+interface Message {
+    id: string;
+    content: string;
+    channelId: string;
+    author: BotUser | {
+        id: string;
+        username: string;
+        displayName: string;
+        avatar: string | null;
+        isBot: boolean;
+    };
+    embed?: Embed | null;
+    components?: MessageComponent[] | null;
+    replyToId?: string | null;
+    attachments: Attachment[];
+    reactions: Reaction[];
+    createdAt: string;
+    editedAt?: string | null;
+    deletedAt?: string | null;
+}
+type InteractionType = 'SLASH_COMMAND' | 'BUTTON_CLICK' | 'SELECT_MENU' | 'MODAL_SUBMIT' | 'AUTOCOMPLETE' | 'CONTEXT_MENU' | 'PREFIX_COMMAND';
+interface Interaction {
+    id: string;
+    type: InteractionType;
+    commandName?: string | null;
+    customId?: string | null;
+    data?: unknown;
+    /** For SELECT_MENU interactions — the chosen option values. */
+    values?: string[];
+    /** For MODAL_SUBMIT interactions — field customId → submitted value. */
+    modalData?: Record<string, string>;
+    /**
+     * For AUTOCOMPLETE interactions — the option being completed and the
+     * partial string the user has typed so far.
+     */
+    autocomplete?: {
+        name: string;
+        value: string;
+    };
+    /**
+     * For CONTEXT_MENU interactions — the ID of the message or user that was
+     * right-clicked.
+     */
+    contextTargetId?: string | null;
+    userId: string;
+    channelId: string;
+    serverId?: string | null;
+    triggerMsgId?: string | null;
+    createdAt: string;
+}
+/** A single text input field inside a bot modal. */
+interface BotModalField {
+    /** Unique field ID — returned as key in `modalData` on MODAL_SUBMIT. */
+    customId: string;
+    /** Label displayed above the input. */
+    label: string;
+    /** `'short'` = single-line input, `'paragraph'` = multi-line textarea. */
+    type: 'short' | 'paragraph';
+    placeholder?: string;
+    required?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    /** Optional pre-filled default value. */
+    value?: string;
+}
+/**
+ * Pass this as `modal` inside `client.interactions.respond()` to open a
+ * modal dialog on the user's client instead of sending a message.
+ *
+ * @example
+ * await client.interactions.respond(interaction.id, {
+ *   modal: {
+ *     title: 'Submit a report',
+ *     customId: 'report_modal',
+ *     fields: [
+ *       { customId: 'reason', label: 'Reason', type: 'paragraph', required: true },
+ *     ],
+ *   },
+ * })
+ */
+interface BotModalDefinition {
+    /** Title shown at the top of the modal dialog. */
+    title: string;
+    /** Custom ID passed back with the MODAL_SUBMIT interaction. */
+    customId: string;
+    fields: BotModalField[];
+}
+interface SlashCommandOption {
+    name: string;
+    description: string;
+    type: 'STRING' | 'INTEGER' | 'NUMBER' | 'BOOLEAN' | 'USER' | 'CHANNEL' | 'ROLE' | 'ATTACHMENT';
+    required?: boolean;
+    /** Whether to enable autocomplete for this option. Mutually exclusive with `choices`. */
+    autocomplete?: boolean;
+    choices?: Array<{
+        name: string;
+        value: string | number;
+    }>;
+    /** Minimum value (for INTEGER / NUMBER types). */
+    minValue?: number;
+    /** Maximum value (for INTEGER / NUMBER types). */
+    maxValue?: number;
+    /** Minimum length (for STRING type). */
+    minLength?: number;
+    /** Maximum length (for STRING type). */
+    maxLength?: number;
+}
+interface SlashCommandDefinition {
+    name: string;
+    description: string;
+    options?: SlashCommandOption[];
+}
+interface PrefixCommandDefinition {
+    prefix: string;
+    name: string;
+    description: string;
+    options?: SlashCommandOption[];
+    guildId?: string | null;
+}
+interface ContextCommandDefinition {
+    name: string;
+    target: 'MESSAGE' | 'USER';
+    guildId?: string | null;
+}
+interface RegisteredSlashCommand {
+    id: string;
+    name: string;
+    description: string;
+    options: SlashCommandOption[];
+    guildId: string | null;
+    enabled: boolean;
+    createdAt: string;
+}
+interface RegisteredPrefixCommand {
+    id: string;
+    prefix: string;
+    name: string;
+    description: string;
+    options: SlashCommandOption[];
+    guildId: string | null;
+    enabled: boolean;
+    createdAt: string;
+}
+interface RegisteredContextCommand {
+    id: string;
+    name: string;
+    target: 'MESSAGE' | 'USER';
+    guildId: string | null;
+    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' | '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;
+    timestamp: string;
+}
+interface SendMessageOptions {
+    content?: string;
+    embed?: Embed;
+    components?: MessageComponent[];
+    replyToId?: string;
+}
+interface EditMessageOptions {
+    content?: string;
+    embed?: Embed;
+    components?: MessageComponent[];
+}
+interface RespondInteractionOptions {
+    content?: string;
+    embed?: Embed;
+    components?: MessageComponent[];
+    ephemeral?: boolean;
+    /**
+     * Open a modal dialog on the user's client instead of sending a message.
+     * When set, all other fields are ignored.
+     */
+    modal?: BotModalDefinition;
+}
+interface FetchMessagesOptions {
+    limit?: number;
+    before?: string;
+}
+interface FetchMembersOptions {
+    limit?: number;
+    /** Return members whose role matches this value. */
+    role?: 'OWNER' | 'ADMIN' | 'MEMBER';
+    /** Filter by partial username (case-insensitive). */
+    search?: string;
+}
+interface PollInteractionsOptions {
+    limit?: number;
+    since?: string;
+}
+interface CreateChannelOptions {
+    name: string;
+    type?: ChannelType;
+    topic?: string;
+    position?: number;
+    slowMode?: number;
+}
+interface EditChannelOptions {
+    name?: string;
+    topic?: string;
+    position?: number;
+    slowMode?: number;
+}
+interface FetchChannelsOptions {
+    type?: ChannelType;
+}
+/** A raw permission record stored for a specific scope (server, role, or channel). */
+interface BotPermissionRecord {
+    id: string;
+    botId: string;
+    serverId: string;
+    /** `null` means this record is server-wide (not channel-scoped). */
+    channelId: string | null;
+    /** `null` means this record applies to all roles. */
+    roleId: string | null;
+    /** Key-value map of permission name → granted flag. */
+    permissions: Record<string, boolean>;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Response from `client.permissions.get()`. */
+interface PermissionsResult {
+    /**
+     * Merged, effective permissions for the requested scope.
+     * Merging order (highest wins): channel > role > server-wide.
+     */
+    permissions: Record<string, boolean>;
+    /** All raw permission records matching the query scope. */
+    records: BotPermissionRecord[];
+}
+/** Options accepted by `client.permissions.get()`. */
+interface PermissionsQueryOptions {
+    /** The server to query permissions for (required). */
+    serverId: string;
+    /** Narrow the scope to a specific channel. */
+    channelId?: string;
+    /** Narrow the scope to a specific role. */
+    roleId?: string;
+}
+/** A direct message sent between the bot and a user. */
+interface DirectMessage {
+    id: string;
+    content: string;
+    /** The sender's user ID. */
+    fromId: string;
+    /** The recipient's user ID. */
+    toId: string;
+    editedAt: string | null;
+    createdAt: string;
+}
+/** Snapshot of a user's voice channel presence. */
+interface VoiceState {
+    userId: string;
+    channelId: string;
+    serverId: string;
+    /** Whether the user's microphone is muted. */
+    muted: boolean;
+    /** Whether the user's audio output is deafened. */
+    deafened: boolean;
+    /** ISO timestamp when the user joined the voice channel. */
+    joinedAt: string;
+}
+interface RoleCreateOptions {
+    name: string;
+    color?: string;
+    hoist?: boolean;
+    /**
+     * Permission flags to grant for this role.
+     * Any key not set retains its default value from the server.
+     */
+    permissions?: Partial<{
+        manageServer: boolean;
+        manageChannels: boolean;
+        manageRoles: boolean;
+        viewAuditLog: boolean;
+        createInvites: boolean;
+        manageWebhooks: boolean;
+        kickMembers: boolean;
+        banMembers: boolean;
+        timeoutMembers: boolean;
+        changeNickname: boolean;
+        manageNicknames: boolean;
+        muteMembers: boolean;
+        deafenMembers: boolean;
+        moveMembers: boolean;
+        sendMessages: boolean;
+        manageMessages: boolean;
+        embedLinks: boolean;
+        attachFiles: boolean;
+        addReactions: boolean;
+        mentionEveryone: boolean;
+        readMessageHistory: boolean;
+    }>;
+}
+type RoleEditOptions = Partial<RoleCreateOptions>;
+interface InviteCreateOptions {
+    /** Maximum number of times the invite can be used. `null` = unlimited. */
+    maxUses?: number | null;
+    /** ISO timestamp when the invite expires. `null` = never expires. */
+    expiresAt?: string | null;
+}
+interface Webhook {
+    id: string;
+    serverId: string;
+    channelId: string;
+    name: string;
+    /** A secret token used to post messages via this webhook. */
+    token: string;
+    createdAt: string;
+}
+interface WebhookCreateOptions {
+    /** Display name shown when the webhook posts a message. */
+    name: string;
+}
+interface WebhookEditOptions {
+    /** New display name for the webhook. */
+    name?: string;
+    /** Move the webhook to a different text channel. */
+    channelId?: string;
+}
+interface ExecuteWebhookOptions {
+    content?: string;
+    embed?: Embed;
+    /** Override the default display name for this execution. */
+    username?: string;
+}
+type AuditLogAction = 'member.kicked' | 'member.banned' | 'member.unbanned' | 'member.role_added' | 'member.role_removed' | 'message.deleted' | 'message.pinned' | 'message.unpinned' | 'channel.created' | 'channel.updated' | 'channel.deleted' | 'role.created' | 'role.updated' | 'role.deleted' | 'invite.created' | 'invite.deleted' | 'webhook.created' | 'webhook.updated' | 'webhook.deleted' | 'server.updated' | string;
+interface AuditLogEntry {
+    id: string;
+    serverId: string;
+    action: AuditLogAction;
+    /** The user who performed the action. */
+    actorId: string;
+    actorName: string;
+    /** The entity affected (user, channel, role, etc.). */
+    targetId: string | null;
+    targetName: string | null;
+    /** Extra context (old/new values, reason, etc.). */
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+}
+interface FetchAuditLogsOptions {
+    limit?: number;
+    /** Only return entries for a specific action type. */
+    action?: AuditLogAction;
+    /** Only return entries targeting a specific user ID. */
+    userId?: string;
+    before?: string;
+}
+interface ServerUpdateOptions {
+    name?: string;
+    description?: string;
+    icon?: string | null;
+}
+/** Extended member object returned when fetching a single member by user ID. */
+interface SingleMember extends Member {
+    /** The custom role assigned to this member, if any. */
+    customRole: Role | null;
+}
+interface NovaClientOptions {
+    /** Your bot token — starts with "nova_bot_" */
+    token: string;
+    /**
+     * Base URL of the Nova server.
+     * @default "https://novachatapp.com"
+     */
+    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 = 'BLOCKED_WORD' | 'BLOCKED_LINK';
+interface AutoModRule {
+    id: string;
+    serverId: string;
+    type: AutoModRuleType;
+    value: string;
+    enabled: boolean;
+    createdAt: string;
+}
+interface CreateAutoModRuleOptions {
+    type: AutoModRuleType;
+    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;
+    constructor(http: HttpClient);
+    /**
+     * Send a message to a channel.
+     *
+     * @example
+     * await client.messages.send('channel-id', { content: 'Hello!' })
+     * await client.messages.send('channel-id', {
+     *   embed: { title: 'Report', description: 'Everything is fine.' }
+     * })
+     */
+    send(channelId: string, options: SendMessageOptions): Promise<Message>;
+    /**
+     * Edit a message previously sent by this bot.
+     */
+    edit(messageId: string, options: EditMessageOptions): Promise<Message>;
+    /**
+     * Delete a message previously sent by this bot.
+     */
+    delete(messageId: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Fetch recent messages from a channel.
+     */
+    fetch(channelId: string, options?: FetchMessagesOptions): Promise<Message[]>;
+    /**
+     * Send a typing indicator in a channel (appears for ~5 seconds).
+     */
+    typing(channelId: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Fetch a single message by ID.
+     *
+     * @example
+     * const msg = await client.messages.fetchOne('message-id')
+     */
+    fetchOne(messageId: string): Promise<Message>;
+    /**
+     * Pin a message in its channel.
+     * The bot must have the `messages.manage` scope.
+     *
+     * @example
+     * await client.messages.pin('message-id')
+     */
+    pin(messageId: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Unpin a message.
+     *
+     * @example
+     * await client.messages.unpin('message-id')
+     */
+    unpin(messageId: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Fetch all pinned messages in a channel.
+     *
+     * @example
+     * const pins = await client.messages.fetchPinned('channel-id')
+     */
+    fetchPinned(channelId: string): Promise<Message[]>;
+    /**
+     * Add a reaction to a message.
+     *
+     * @example
+     * await client.messages.addReaction('message-id', '👍')
+     */
+    addReaction(messageId: string, emoji: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Remove the bot's reaction from a message.
+     *
+     * @example
+     * await client.messages.removeReaction('message-id', '👍')
+     */
+    removeReaction(messageId: string, emoji: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Fetch all reactions on a message.
+     *
+     * @example
+     * const reactions = await client.messages.fetchReactions('message-id')
+     */
+    fetchReactions(messageId: string): Promise<ReactionDetail[]>;
+}
+
+declare class CommandsAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Register (or fully replace) slash commands.
+     * Pass `guildId` to register guild-specific commands; omit for global.
+     *
+     * @example
+     * await client.commands.setSlash([
+     *   { name: 'ping', description: 'Responds with pong!' },
+     *   { name: 'ban', description: 'Ban a user', options: [
+     *     { name: 'user', description: 'User to ban', type: 'USER', required: true }
+     *   ]}
+     * ])
+     */
+    setSlash(commands: SlashCommandDefinition[], guildId?: string): Promise<{
+        registered: number;
+    }>;
+    /**
+     * Fetch all registered slash commands.
+     */
+    getSlash(guildId?: string): Promise<RegisteredSlashCommand[]>;
+    /**
+     * Delete a slash command by name.
+     */
+    deleteSlash(name: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Register (or fully replace) prefix commands.
+     *
+     * @example
+     * await client.commands.setPrefix([
+     *   { prefix: '!', name: 'help', description: 'Show help' },
+     *   { prefix: '!', name: 'kick', description: 'Kick a user' },
+     * ])
+     */
+    setPrefix(commands: PrefixCommandDefinition[]): Promise<{
+        created: number;
+    }>;
+    /**
+     * Fetch all registered prefix commands.
+     */
+    getPrefix(): Promise<RegisteredPrefixCommand[]>;
+    /**
+     * Delete a prefix command.
+     */
+    deletePrefix(prefix: string, name: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Register (or fully replace) context menu commands.
+     *
+     * @example
+     * await client.commands.setContext([
+     *   { name: 'Report message', target: 'MESSAGE' },
+     *   { name: 'View profile', target: 'USER' },
+     * ])
+     */
+    setContext(commands: ContextCommandDefinition[]): Promise<{
+        created: number;
+    }>;
+    /**
+     * Fetch all registered context menu commands.
+     */
+    getContext(): Promise<RegisteredContextCommand[]>;
+    /**
+     * Delete a context menu command by name.
+     */
+    deleteContext(name: string): Promise<{
+        ok: true;
+    }>;
+}
+
+declare class MembersAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Fetch members of a server the bot is in.
+     * Supports filtering by role and searching by username/displayName.
+     *
+     * @example
+     * const members = await client.members.list('server-id', { limit: 50 })
+     * const admins = await client.members.list('server-id', { role: 'ADMIN' })
+     * const found = await client.members.list('server-id', { search: 'john' })
+     */
+    list(serverId: string, options?: FetchMembersOptions): Promise<Member[]>;
+    /**
+     * Fetch a single member from a server by their user ID.
+     * Returns the member's custom role if assigned.
+     * Requires the `members.read` scope.
+     *
+     * @example
+     * const member = await client.members.fetch('server-id', 'user-id')
+     * console.log(member.customRole?.name ?? 'No custom role')
+     */
+    fetch(serverId: string, userId: string): Promise<SingleMember>;
+    /**
+     * Kick a member from a server.
+     * Bots cannot kick owners or admins (403 will be thrown).
+     *
+     * @example
+     * await client.members.kick('server-id', 'user-id')
+     */
+    kick(serverId: string, userId: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Ban a member from a server.
+     * Bots cannot ban owners or admins (403 will be thrown).
+     *
+     * @example
+     * await client.members.ban('server-id', 'user-id', 'Spamming')
+     */
+    ban(serverId: string, userId: string, reason?: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Unban a previously banned user.
+     * Requires the `members.ban` scope.
+     *
+     * @example
+     * await client.members.unban('server-id', 'user-id')
+     */
+    unban(serverId: string, userId: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Fetch the ban list for a server.
+     * Requires the `members.ban` scope.
+     *
+     * @example
+     * const bans = await client.members.listBans('server-id')
+     * for (const ban of bans) {
+     *   console.log(`${ban.username} — ${ban.reason ?? 'No reason'}`)
+     * }
+     */
+    listBans(serverId: string): Promise<BanEntry[]>;
+    /**
+     * Send a direct message to a user (DM).
+     * Requires the `messages.write` scope.
+     *
+     * @example
+     * await client.members.dm('user-id', { content: 'Hello!' })
+     * await client.members.dm('user-id', 'Hello from the bot!')
+     */
+    dm(userId: string, options: string | Omit<SendMessageOptions, 'replyToId'>): Promise<Message>;
+    /**
+     * Add a role to a member.
+     * Requires the `members.roles` scope.
+     *
+     * @example
+     * await client.members.addRole('server-id', 'user-id', 'role-id')
+     */
+    addRole(serverId: string, userId: string, roleId: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Remove a role from a member.
+     * Requires the `members.roles` scope.
+     *
+     * @example
+     * await client.members.removeRole('server-id', 'user-id', 'role-id')
+     */
+    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 {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Fetch all servers the bot is currently a member of.
+     *
+     * @example
+     * const servers = await client.servers.list()
+     * console.log(`Bot is in ${servers.length} servers`)
+     */
+    list(): Promise<NovaServer[]>;
+    /**
+     * Fetch a single server by ID.
+     * The bot must be a member of the server.
+     *
+     * @example
+     * const server = await client.servers.fetch('server-id')
+     * console.log(`${server.name} — ${server.memberCount} members`)
+     */
+    fetch(serverId: string): Promise<NovaServer>;
+    /**
+     * Update a server's name, description, or icon.
+     * Requires the `server.manage` scope.
+     *
+     * @example
+     * await client.servers.update('server-id', { name: 'Better Name', description: 'A great place!' })
+     */
+    update(serverId: string, options: ServerUpdateOptions): Promise<NovaServer>;
+    /**
+     * Fetch all roles in a server.
+     * Results are sorted by position (lowest first).
+     *
+     * @example
+     * const roles = await client.servers.listRoles('server-id')
+     * 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 {
+    private readonly http;
+    private readonly emitter;
+    constructor(http: HttpClient, emitter: EventEmitter);
+    /**
+     * Acknowledge an interaction without sending a visible response.
+     * Shows a loading state to the user. You must follow up with `respond()`.
+     *
+     * @example
+     * client.on('interactionCreate', async (interaction) => {
+     *   await client.interactions.ack(interaction.id)
+     *   // ... do work ...
+     *   await client.interactions.respond(interaction.id, { content: 'Done!' })
+     * })
+     */
+    ack(interactionId: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Respond to an interaction with a message.
+     * Set `ephemeral: true` to only show the response to the triggering user.
+     *
+     * @example
+     * await client.interactions.respond(interaction.id, {
+     *   content: 'Pong!',
+     *   ephemeral: true,
+     * })
+     */
+    respond(interactionId: string, options: RespondInteractionOptions): Promise<Message | {
+        ok: true;
+        ephemeral: true;
+    }>;
+    /**
+     * Respond to an autocomplete interaction with a list of suggested choices.
+     * The gateway fires `AUTOCOMPLETE` interactions when a user is typing in
+     * an option that has `autocomplete: true`.  Call this within ~3 seconds.
+     *
+     * @example
+     * client.autocomplete('search', async (interaction) => {
+     *   const query = interaction.autocomplete?.value ?? ''
+     *   const results = await db.search(query)
+     *   await client.interactions.autocomplete(interaction.id,
+     *     results.map(r => ({ name: r.title, value: r.id }))
+     *   )
+     * })
+     */
+    autocomplete(interactionId: string, choices: Array<{
+        name: string;
+        value: string | number;
+    }>): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Poll for pending (unacknowledged) interactions.
+     * Useful when not using the WebSocket gateway.
+     *
+     * @example
+     * const pending = await client.interactions.poll({ limit: 20 })
+     * for (const i of pending) {
+     *   await client.interactions.respond(i.id, { content: 'Got it!' })
+     * }
+     */
+    poll(options?: PollInteractionsOptions): Promise<Interaction[]>;
+    /**
+     * Open a modal for the user who triggered an interaction and await their submission.
+     *
+     * Internally this:
+     *  1. Calls `respond(interactionId, { modal })` to push the modal to the client UI.
+     *  2. Listens for the next `interactionCreate` event whose type is `MODAL_SUBMIT`
+     *     and whose `customId` matches your modal's `customId`.
+     *  3. Resolves with the submitted `Interaction` (containing `modalData`), or `null`
+     *     if the user closes the modal without submitting within the timeout.
+     *
+     * @param interactionId - ID of the triggering interaction.
+     * @param modal         - Modal definition (title, customId, fields).
+     * @param options.timeout - Max milliseconds to wait (default: 300 000 = 5 min).
+     *
+     * @example
+     * client.on('interactionCreate', async (interaction) => {
+     *   if (interaction.commandName === 'report') {
+     *     const submitted = await client.interactions.awaitModal(interaction.id, {
+     *       title: 'Submit a report',
+     *       customId: 'report_modal',
+     *       fields: [
+     *         { customId: 'reason', label: 'Reason', type: 'paragraph', required: true, maxLength: 500 },
+     *       ],
+     *     })
+     *
+     *     if (!submitted) {
+     *       // User dismissed the modal or timed out — nothing to do
+     *       return
+     *     }
+     *
+     *     const reason = submitted.modalData?.reason
+     *     await client.interactions.respond(submitted.id, {
+     *       content: `Report received: ${reason}`,
+     *       ephemeral: true,
+     *     })
+     *   }
+     * })
+     */
+    awaitModal(interactionId: string, modal: BotModalDefinition, options?: {
+        timeout?: number;
+    }): Promise<Interaction | null>;
+}
+
+declare class PermissionsAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Fetch the bot's effective permissions for a given scope.
+     *
+     * Permissions are merged in priority order:
+     * 1. Server-wide base permissions
+     * 2. Role override (if `roleId` provided)
+     * 3. Channel override (if `channelId` provided, highest priority)
+     *
+     * `serverId` is required. `channelId` and `roleId` are optional filters.
+     *
+     * @example
+     * // Effective server-wide permissions
+     * const { permissions } = await client.permissions.get({
+     *   serverId: 'server-id',
+     * })
+     * console.log(permissions) // { kick_members: true, ban_members: false, ... }
+     *
+     * @example
+     * // Scoped to a specific channel
+     * const { permissions } = await client.permissions.get({
+     *   serverId: 'server-id',
+     *   channelId: 'channel-id',
+     * })
+     *
+     * @example
+     * // Scoped to a specific role
+     * const { permissions } = await client.permissions.get({
+     *   serverId: 'server-id',
+     *   roleId: 'role-id',
+     * })
+     */
+    get(options: PermissionsQueryOptions): Promise<PermissionsResult>;
+}
+
+declare class ChannelsAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Fetch all channels in a server the bot is a member of.
+     *
+     * @example
+     * const channels = await client.channels.list('server-id')
+     * const textChannels = channels.filter(c => c.type === 'TEXT')
+     */
+    list(serverId: string): Promise<Channel[]>;
+    /**
+     * Fetch a single channel by ID.
+     *
+     * @example
+     * const channel = await client.channels.fetch('channel-id')
+     * console.log(channel.name, channel.type)
+     */
+    fetch(channelId: string): Promise<Channel>;
+    /**
+     * Create a new channel in a server.
+     * Requires the `channels.manage` scope.
+     *
+     * @example
+     * const channel = await client.channels.create('server-id', {
+     *   name: 'announcements',
+     *   type: 'ANNOUNCEMENT',
+     *   topic: 'Official announcements only',
+     * })
+     */
+    create(serverId: string, options: CreateChannelOptions): Promise<Channel>;
+    /**
+     * Edit an existing channel.
+     * Requires the `channels.manage` scope.
+     *
+     * @example
+     * await client.channels.edit('channel-id', { topic: 'New topic!' })
+     */
+    edit(channelId: string, options: EditChannelOptions): Promise<Channel>;
+    /**
+     * Delete a channel.
+     * Requires the `channels.manage` scope.
+     *
+     * @example
+     * await client.channels.delete('channel-id')
+     */
+    delete(channelId: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Fetch messages from a channel.
+     *
+     * @example
+     * const messages = await client.channels.fetchMessages('channel-id', { limit: 50 })
+     */
+    fetchMessages(channelId: string, options?: FetchMessagesOptions): Promise<Message[]>;
+    /**
+     * Fetch all pinned messages in a channel.
+     *
+     * @example
+     * const pins = await client.channels.fetchPins('channel-id')
+     */
+    fetchPins(channelId: string): Promise<Message[]>;
+    /**
+     * Send a typing indicator in a channel.
+     * Displayed to users for ~5 seconds.
+     *
+     * @example
+     * await client.channels.startTyping('channel-id')
+     */
+    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 {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Add a reaction to a message.
+     * Use a plain emoji character or a custom emoji ID.
+     *
+     * @example
+     * await client.reactions.add('message-id', '👍')
+     * await client.reactions.add('message-id', '🎉')
+     */
+    add(messageId: string, emoji: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Remove the bot's reaction from a message.
+     *
+     * @example
+     * await client.reactions.remove('message-id', '👍')
+     */
+    remove(messageId: string, emoji: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Remove all reactions from a message.
+     * Requires the `messages.manage` scope.
+     *
+     * @example
+     * await client.reactions.removeAll('message-id')
+     */
+    removeAll(messageId: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Remove all reactions of a specific emoji from a message.
+     * Requires the `messages.manage` scope.
+     *
+     * @example
+     * await client.reactions.removeEmoji('message-id', '👍')
+     */
+    removeEmoji(messageId: string, emoji: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Fetch all reactions on a message, broken down by emoji.
+     *
+     * @example
+     * const reactions = await client.reactions.fetch('message-id')
+     * for (const r of reactions) {
+     *   console.log(`${r.emoji} — ${r.count} reactions from ${r.users.map(u => u.username).join(', ')}`)
+     * }
+     */
+    fetch(messageId: string): Promise<ReactionDetail[]>;
+    /**
+     * Fetch reactions for a specific emoji on a message.
+     *
+     * @example
+     * const detail = await client.reactions.fetchEmoji('message-id', '👍')
+     * console.log(`${detail.count} thumbs ups`)
+     */
+    fetchEmoji(messageId: string, emoji: string): Promise<ReactionDetail>;
+}
+
+declare class RolesAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List all custom roles in a server, sorted by position.
+     *
+     * @example
+     * const roles = await client.roles.list('server-id')
+     * const adminRole = roles.find(r => r.name === 'Admin')
+     */
+    list(serverId: string): Promise<Role[]>;
+    /**
+     * Create a new custom role in a server.
+     * Requires the `roles.manage` scope.
+     *
+     * @example
+     * const role = await client.roles.create('server-id', {
+     *   name: 'Verified',
+     *   color: '#00d4ff',
+     *   hoist: true,
+     *   permissions: { sendMessages: true, addReactions: true },
+     * })
+     */
+    create(serverId: string, options: RoleCreateOptions): Promise<Role>;
+    /**
+     * Edit an existing role.
+     * Requires the `roles.manage` scope.
+     *
+     * @example
+     * await client.roles.edit('role-id', { color: '#ff0000', name: 'Danger' })
+     */
+    edit(roleId: string, options: RoleEditOptions): Promise<Role>;
+    /**
+     * Delete a custom role from a server.
+     * Any member currently assigned this role will have it removed automatically.
+     * Requires the `roles.manage` scope.
+     *
+     * @example
+     * await client.roles.delete('role-id')
+     */
+    delete(roleId: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Assign a custom role to a server member.
+     * Requires the `members.roles` scope.
+     *
+     * @example
+     * await client.roles.assign('server-id', 'user-id', 'role-id')
+     */
+    assign(serverId: string, userId: string, roleId: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Remove a custom role from a server member.
+     * Requires the `members.roles` scope.
+     *
+     * @example
+     * await client.roles.remove('server-id', 'user-id', 'role-id')
+     */
+    remove(serverId: string, userId: string, roleId: string): Promise<{
+        ok: true;
+    }>;
+}
+
+declare class InvitesAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List all active invites for a server.
+     *
+     * @example
+     * const invites = await client.invites.list('server-id')
+     * console.log(`${invites.length} active invites`)
+     */
+    list(serverId: string): Promise<Invite[]>;
+    /**
+     * Create a new invite for a server.
+     * Requires the `invites.manage` scope.
+     *
+     * @example
+     * // A one-time invite that expires in 24 hours
+     * const invite = await client.invites.create('server-id', {
+     *   maxUses: 1,
+     *   expiresAt: new Date(Date.now() + 86_400_000).toISOString(),
+     * })
+     * console.log(`https://novachatapp.com/invite/${invite.code}`)
+     */
+    create(serverId: string, options?: InviteCreateOptions): Promise<Invite>;
+    /**
+     * Fetch a single invite by its code.
+     *
+     * @example
+     * const invite = await client.invites.fetch('abc123')
+     * console.log(`${invite.uses} / ${invite.maxUses ?? '∞'} uses`)
+     */
+    fetch(code: string): Promise<Invite>;
+    /**
+     * Revoke (delete) an invite.
+     * Requires the `invites.manage` scope.
+     *
+     * @example
+     * await client.invites.revoke('abc123')
+     */
+    revoke(code: string): Promise<{
+        ok: true;
+    }>;
+}
+
+declare class WebhooksAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List all webhooks in a channel.
+     * Requires the `webhooks.manage` scope.
+     *
+     * @example
+     * const webhooks = await client.webhooks.list('channel-id')
+     */
+    list(channelId: string): Promise<Webhook[]>;
+    /**
+     * Create a webhook in a channel.
+     * Requires the `webhooks.manage` scope.
+     *
+     * @example
+     * const webhook = await client.webhooks.create('channel-id', { name: 'Announcements' })
+     * console.log('Token:', webhook.token)
+     */
+    create(channelId: string, options: WebhookCreateOptions): Promise<Webhook>;
+    /**
+     * Fetch a webhook by its ID.
+     * Requires the `webhooks.manage` scope.
+     *
+     * @example
+     * const webhook = await client.webhooks.fetch('webhook-id')
+     */
+    fetch(webhookId: string): Promise<Webhook>;
+    /**
+     * Edit a webhook's name and/or target channel.
+     * Requires the `webhooks.manage` scope.
+     *
+     * @example
+     * await client.webhooks.edit('webhook-id', { name: 'New Name', channelId: 'other-channel' })
+     */
+    edit(webhookId: string, options: WebhookEditOptions): Promise<Webhook>;
+    /**
+     * Delete a webhook.
+     * Requires the `webhooks.manage` scope.
+     *
+     * @example
+     * await client.webhooks.delete('webhook-id')
+     */
+    delete(webhookId: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Execute a webhook — post a message to the webhook's channel.
+     * Does not require any extra scope (uses the webhook data already owned by
+     * this bot application).
+     *
+     * @example
+     * await client.webhooks.execute('webhook-id', {
+     *   content: '🚀 Deployment successful!',
+     *   username: 'Deploy Bot',
+     * })
+     */
+    execute(webhookId: string, options: ExecuteWebhookOptions): Promise<Message>;
+}
+
+declare class AuditLogAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Fetch the audit log for a server.
+     * Requires the `audit-log.read` scope.
+     *
+     * You can filter by action type, actor user ID, and paginate backwards
+     * using the `before` cursor (an ISO timestamp).
+     *
+     * @example
+     * // Most recent 50 entries
+     * const entries = await client.auditLog.fetch('server-id')
+     *
+     * // Only kick and ban actions
+     * const modActions = await client.auditLog.fetch('server-id', {
+     *   action: 'member.banned',
+     *   limit: 20,
+     * })
+     *
+     * // All actions performed by a specific user
+     * const byUser = await client.auditLog.fetch('server-id', { userId: 'user-id' })
+     */
+    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.
+ *
+ * @example
+ * new TextInputBuilder()
+ *   .setCustomId('reason')
+ *   .setLabel('Reason')
+ *   .setStyle('paragraph')
+ *   .setPlaceholder('Describe the issue in detail…')
+ *   .setRequired(true)
+ *   .setMaxLength(1000)
+ */
+declare class TextInputBuilder {
+    private _data;
+    /** Unique ID for this field — the key in `interaction.modalData` on submit. */
+    setCustomId(customId: string): this;
+    /** Label shown above the input inside the modal. */
+    setLabel(label: string): this;
+    /**
+     * Input style:
+     * - `'short'` — single-line text input
+     * - `'paragraph'` — multi-line textarea
+     */
+    setStyle(style: TextInputStyle): this;
+    /** Greyed-out hint text shown when the field is empty. */
+    setPlaceholder(placeholder: string): this;
+    /** Whether the user must fill in this field before submitting. */
+    setRequired(required?: boolean): this;
+    /** Minimum number of characters required. */
+    setMinLength(min: number): this;
+    /** Maximum number of characters allowed. */
+    setMaxLength(max: number): this;
+    /** Pre-filled default value. */
+    setValue(value: string): this;
+    toJSON(): BotModalField;
+}
+
+type FieldLike = TextInputBuilder | BotModalField;
+/**
+ * Fluent builder for bot modal dialogs.
+ *
+ * @example
+ * const modal = new ModalBuilder()
+ *   .setTitle('Submit a report')
+ *   .setCustomId('report_modal')
+ *   .addField(
+ *     new TextInputBuilder()
+ *       .setCustomId('reason')
+ *       .setLabel('Reason')
+ *       .setStyle('paragraph')
+ *       .setRequired(true)
+ *       .setMaxLength(1000)
+ *   )
+ *   .addField(
+ *     new TextInputBuilder()
+ *       .setCustomId('proof')
+ *       .setLabel('Evidence (optional URL)')
+ *       .setStyle('short')
+ *   )
+ *
+ * const submitted = await interaction.openModal(modal)
+ * if (submitted) {
+ *   const reason = submitted.modalData.reason
+ * }
+ */
+declare class ModalBuilder {
+    private _title;
+    private _customId;
+    private readonly _fields;
+    /** Title shown at the top of the modal dialog. */
+    setTitle(title: string): this;
+    /** Custom ID passed back with the `MODAL_SUBMIT` interaction. */
+    setCustomId(customId: string): this;
+    /** Add a single text-input field. */
+    addField(field: FieldLike): this;
+    /** Add multiple fields at once. */
+    addFields(...fields: FieldLike[]): this;
+    toJSON(): BotModalDefinition;
+}
+
+/**
+ * Typed accessor for slash- and prefix-command options.
+ * Available via `interaction.options`.
+ *
+ * @example
+ * client.command('ban', async (interaction) => {
+ *   const userId = interaction.options.getString('user', true)
+ *   const reason = interaction.options.getString('reason') ?? 'No reason given'
+ * })
+ */
+declare class InteractionOptions {
+    private readonly _map;
+    constructor(data: unknown);
+    /** Whether this option was supplied by the user. */
+    has(name: string): boolean;
+    /** @overload Required — never returns `null`. */
+    getString(name: string, required: true): string;
+    /** @overload Optional — returns `null` when not supplied. */
+    getString(name: string, required?: false): string | null;
+    /** @overload Required — never returns `null`. */
+    getInteger(name: string, required: true): number;
+    /** @overload Optional — returns `null` when not supplied. */
+    getInteger(name: string, required?: false): number | null;
+    /** @overload Required — never returns `null`. */
+    getNumber(name: string, required: true): number;
+    /** @overload Optional — returns `null` when not supplied. */
+    getNumber(name: string, required?: false): number | null;
+    /** Returns `true` or `false`, or `null` if not supplied. */
+    getBoolean(name: string): boolean | null;
+    /**
+     * Returns the mentioned **user ID** string (type `USER` option).
+     * @overload Required.
+     */
+    getUser(name: string, required: true): string;
+    getUser(name: string, required?: false): string | null;
+    /**
+     * Returns the mentioned **channel ID** string (type `CHANNEL` option).
+     * @overload Required.
+     */
+    getChannel(name: string, required: true): string;
+    getChannel(name: string, required?: false): string | null;
+    /**
+     * Returns the mentioned **role ID** string (type `ROLE` option).
+     * @overload Required.
+     */
+    getRole(name: string, required: true): string;
+    getRole(name: string, required?: false): string | null;
+}
+/**
+ * Rich wrapper around a raw bot interaction.
+ * Returned by `interactionCreate`, `client.command()`, `client.button()`, `client.selectMenu()`.
+ *
+ * @example
+ * client.on('interactionCreate', async (interaction) => {
+ *   if (interaction.isSlashCommand() && interaction.commandName === 'ping') {
+ *     await interaction.reply('Pong! 🏓')
+ *   }
+ * })
+ *
+ * // Or use built-in routing:
+ * client.command('ping', async (interaction) => {
+ *   await interaction.reply('Pong! 🏓')
+ * })
+ */
+declare class NovaInteraction {
+    private readonly _raw;
+    private readonly _api;
+    /** Unique interaction ID. */
+    readonly id: string;
+    /** Interaction type. Use type guards (`.isSlashCommand()` etc.) for narrowing. */
+    readonly type: InteractionType;
+    /** Command name — set for `SLASH_COMMAND` and `PREFIX_COMMAND` interactions. */
+    readonly commandName: string | null;
+    /** Component custom ID — set for `BUTTON_CLICK`, `SELECT_MENU`, and `MODAL_SUBMIT` interactions. */
+    readonly customId: string | null;
+    /** ID of the user who triggered this interaction. */
+    readonly userId: string;
+    /** ID of the channel where this interaction occurred. */
+    readonly channelId: string;
+    /** ID of the server where this interaction occurred (`null` in DMs). */
+    readonly serverId: string | null;
+    /** ID of the message that contained the button/select component (if any). */
+    readonly triggerMsgId: string | null;
+    /** Selected option values for `SELECT_MENU` interactions. */
+    readonly values: string[];
+    /**
+     * Field values submitted in a `MODAL_SUBMIT` interaction.
+     * Keys are the `customId`s of the `TextInputBuilder` fields.
+     *
+     * @example
+     * const reason = interaction.modalData.reason
+     */
+    readonly modalData: Record<string, string>;
+    /** ISO timestamp of when the interaction was created. */
+    readonly createdAt: string;
+    /**
+     * Typed accessor for slash/prefix command options.
+     *
+     * @example
+     * const userId = interaction.options.getUser('user', true)
+     * const reason = interaction.options.getString('reason') ?? 'No reason given'
+     */
+    readonly options: InteractionOptions;
+    constructor(_raw: Interaction, _api: InteractionsAPI);
+    /**
+     * For `AUTOCOMPLETE` interactions — the option being completed.
+     * Contains `name` (option name) and `value` (partial text typed so far).
+     * `null` for all other interaction types.
+     *
+     * @example
+     * client.autocomplete('search', async (interaction) => {
+     *   const query = interaction.autocomplete?.value ?? ''
+     *   await interaction.respondAutocomplete([{ name: query, value: query }])
+     * })
+     */
+    get autocomplete(): {
+        name: string;
+        value: string;
+    } | null;
+    /** `true` when triggered by a `/slash` command. */
+    isSlashCommand(): boolean;
+    /** `true` when triggered by a `!prefix` command. */
+    isPrefixCommand(): boolean;
+    /** `true` for both slash and prefix commands. */
+    isCommand(): boolean;
+    /** `true` when a button component was clicked. */
+    isButton(): boolean;
+    /** `true` when a select-menu option was chosen. */
+    isSelectMenu(): boolean;
+    /** `true` when the user submitted a modal form. */
+    isModalSubmit(): boolean;
+    /** `true` during autocomplete suggestion requests. */
+    isAutocomplete(): boolean;
+    /**
+     * Send autocomplete suggestions back to the user.
+     * Call this inside a `client.autocomplete()` handler.
+     * Up to 25 choices are shown; each needs a `name` (displayed) and `value` (submitted).
+     *
+     * @example
+     * client.autocomplete('color', async (interaction) => {
+     *   const query = interaction.autocomplete?.value ?? ''
+     *   const colors = ['red', 'green', 'blue'].filter(c => c.startsWith(query))
+     *   await interaction.respondAutocomplete(colors.map(c => ({ name: c, value: c })))
+     * })
+     */
+    respondAutocomplete(choices: Array<{
+        name: string;
+        value: string | number;
+    }>): Promise<{
+        ok: true;
+    }>;
+    /** `true` when triggered via a context-menu command. */
+    isContextMenu(): boolean;
+    /**
+     * Respond with a message.
+     * Accepts a plain string or a full options object.
+     *
+     * @example
+     * await interaction.reply('Pong! 🏓')
+     * await interaction.reply({ content: 'Done!', ephemeral: true })
+     * await interaction.reply({ embed: new EmbedBuilder().setTitle('Stats').toJSON() })
+     */
+    reply(options: RespondInteractionOptions | string): Promise<Message | {
+        ok: true;
+        ephemeral: true;
+    }>;
+    /**
+     * Respond with a message **only visible to the user** who triggered the interaction.
+     *
+     * @example
+     * await interaction.replyEphemeral('Only you can see this!')
+     */
+    replyEphemeral(options: string | Omit<RespondInteractionOptions, 'ephemeral'>): Promise<{
+        ok: true;
+        ephemeral: true;
+    }>;
+    /**
+     * Acknowledge the interaction without sending a response yet.
+     * Shows a loading indicator to the user.
+     * Follow up with `interaction.editReply()` when you're done.
+     *
+     * @example
+     * await interaction.defer()
+     * const data = await fetchSomeSlow()
+     * await interaction.editReply({ content: `Result: ${data}` })
+     */
+    defer(): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Edit the previous reply (e.g. after `defer()`).
+     *
+     * @example
+     * await interaction.defer()
+     * await interaction.editReply(`Done — processed ${count} items.`)
+     */
+    editReply(options: RespondInteractionOptions | string): Promise<Message | {
+        ok: true;
+        ephemeral: true;
+    }>;
+    /**
+     * Open a **modal dialog** and return the user's submission as a new `NovaInteraction`.
+     * Returns `null` if the user closes the modal or the timeout expires (default: 5 min).
+     *
+     * **This is the recommended way to open modals.**
+     *
+     * @example
+     * const submitted = await interaction.openModal(
+     *   new ModalBuilder()
+     *     .setTitle('Submit a report')
+     *     .setCustomId('report_modal')
+     *     .addField(
+     *       new TextInputBuilder()
+     *         .setCustomId('reason')
+     *         .setLabel('Reason')
+     *         .setStyle('paragraph')
+     *         .setRequired(true)
+     *     )
+     * )
+     *
+     * if (!submitted) return // user dismissed or timed out
+     *
+     * const reason = submitted.modalData.reason
+     * await submitted.replyEphemeral(`Report received: ${reason}`)
+     */
+    openModal(modal: ModalBuilder | BotModalDefinition, options?: {
+        timeout?: number;
+    }): Promise<NovaInteraction | null>;
+    /** Returns the raw interaction data from the gateway. */
+    toJSON(): Interaction;
+}
+
+/**
+ * A rich wrapper around a raw `Message` with convenience methods.
+ *
+ * Returned by `client.on('messageCreate', ...)` and from message fetch calls.
+ *
+ * @example
+ * client.on('messageCreate', async (msg) => {
+ *   if (msg.content.toLowerCase() === '!ping') {
+ *     await msg.reply('Pong! 🏓')
+ *     await msg.react('🏓')
+ *   }
+ * })
+ */
+declare class NovaMessage {
+    /** The raw message ID. */
+    readonly id: string;
+    /** The message text content. */
+    readonly content: string;
+    /** The channel this message was sent in. */
+    readonly channelId: string;
+    /** The author of the message. */
+    readonly author: Message['author'];
+    /** Embed attached to this message, if any. */
+    readonly embed: Embed | null;
+    /** Interactive components (buttons, selects) attached to this message. */
+    readonly components: MessageComponent[];
+    /** The message this is replying to, if any. */
+    readonly replyToId: string | null;
+    /** Uploaded file attachments. */
+    readonly attachments: Attachment[];
+    /** Reactions on this message. */
+    readonly reactions: Reaction[];
+    /** When the message was sent. */
+    readonly createdAt: Date;
+    /** When the message was last edited, or `null`. */
+    readonly editedAt: Date | null;
+    private readonly _messages;
+    private readonly _reactions;
+    constructor(raw: Message, messages: MessagesAPI, reactions: ReactionsAPI);
+    /** Returns true if the message was sent by a bot. */
+    isFromBot(): boolean;
+    /** Returns true if the message has an embed. */
+    hasEmbed(): boolean;
+    /** Returns true if the message has interactive components. */
+    hasComponents(): boolean;
+    /** Returns true if the message has been edited. */
+    isEdited(): boolean;
+    /**
+     * Add a reaction to this message.
+     *
+     * @example
+     * await msg.react('👍')
+     * await msg.react('🎉')
+     */
+    react(emoji: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Remove the bot's reaction from this message.
+     *
+     * @example
+     * await msg.removeReaction('👍')
+     */
+    removeReaction(emoji: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Reply to this message.
+     *
+     * @example
+     * await msg.reply('Got it!')
+     * await msg.reply({ embed: new EmbedBuilder().setTitle('Result').toJSON() })
+     */
+    reply(options: string | Omit<SendMessageOptions, 'replyToId'>): Promise<NovaMessage>;
+    /**
+     * Edit this message.
+     * Only works if the bot is the author.
+     *
+     * @example
+     * await msg.edit('Updated content')
+     * await msg.edit({ content: 'Updated', embed: { title: 'New embed' } })
+     */
+    edit(options: string | EditMessageOptions): Promise<NovaMessage>;
+    /**
+     * Delete this message.
+     * Only works if the bot is the author.
+     *
+     * @example
+     * await msg.delete()
+     */
+    delete(): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Pin this message in its channel.
+     *
+     * @example
+     * await msg.pin()
+     */
+    pin(): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Unpin this message.
+     *
+     * @example
+     * await msg.unpin()
+     */
+    unpin(): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Re-fetch the latest version of this message from the server.
+     *
+     * @example
+     * const fresh = await msg.fetch()
+     */
+    fetch(): Promise<NovaMessage>;
+    /**
+     * 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)
+     */
+    forward(channelId: string): Promise<NovaMessage>;
+    /**
+     * 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 👍')
+     */
+    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 })
+ */
+declare class NovaChannel {
+    /** The channel's unique ID. */
+    readonly id: string;
+    /** The channel's name (without #). */
+    readonly name: string;
+    /** The channel type — `'TEXT'`, `'VOICE'`, `'ANNOUNCEMENT'`, `'FORUM'`, or `'STAGE'`. */
+    readonly type: ChannelType;
+    /** The ID of the server this channel belongs to. */
+    readonly serverId: string | null;
+    /** Optional topic / description text. */
+    readonly topic: string | null;
+    /** Sorting position (lower = higher in the list). */
+    readonly position: number;
+    /** Slow-mode interval in seconds (`0` = disabled). */
+    readonly slowMode: number;
+    /** When the channel was created. */
+    readonly createdAt: Date;
+    private readonly _channels;
+    private readonly _messages;
+    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. */
+    isVoice(): boolean;
+    /** `true` for announcement channels. */
+    isAnnouncement(): boolean;
+    /** `true` for forum channels. */
+    isForum(): boolean;
+    /** `true` for stage channels. */
+    isStage(): boolean;
+    /** `true` if slow-mode is enabled on this channel. */
+    hasSlowMode(): boolean;
+    /**
+     * Send a message to this channel.
+     * Accepts a plain string or a full options object.
+     *
+     * @example
+     * await channel.send('Hello!')
+     * await channel.send({ content: 'Hi', embed: { title: 'Stats' } })
+     */
+    send(options: string | SendMessageOptions): Promise<Message>;
+    /**
+     * Fetch recent messages from this channel.
+     *
+     * @example
+     * const messages = await channel.fetchMessages({ limit: 50 })
+     */
+    fetchMessages(options?: FetchMessagesOptions): Promise<Message[]>;
+    /**
+     * Fetch all pinned messages in this channel.
+     *
+     * @example
+     * const pins = await channel.fetchPins()
+     */
+    fetchPins(): Promise<Message[]>;
+    /**
+     * Start a typing indicator (shows "Bot is typing…" for ~5 seconds).
+     *
+     * @example
+     * await channel.startTyping()
+     */
+    startTyping(): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Edit this channel's properties.
+     * Requires the `channels.manage` scope.
+     *
+     * @example
+     * await channel.edit({ name: 'general-2', topic: 'The second general channel' })
+     */
+    edit(options: EditChannelOptions): Promise<NovaChannel>;
+    /**
+     * Delete this channel.
+     * Requires the `channels.manage` scope.
+     *
+     * @example
+     * await channel.delete()
+     */
+    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`.
+     */
+    toString(): string;
+    /** Returns the raw channel data. */
+    toJSON(): Channel;
+}
+
+/**
+ * A rich wrapper around a raw `Member` with convenience methods.
+ *
+ * Returned by `client.fetchMember()` and `client.fetchMembers()`.
+ *
+ * @example
+ * const member = await client.fetchMember('server-id', 'user-id')
+ *
+ * if (member.isAdmin()) {
+ *   await member.dm('You have admin access.')
+ * } else {
+ *   await member.kick()
+ * }
+ */
+declare class NovaMember {
+    /** The user's unique ID. */
+    readonly userId: string;
+    /** The server this membership belongs to. */
+    readonly serverId: string;
+    /** The user's username (login handle). */
+    readonly username: string;
+    /** The user's display name. */
+    readonly displayName: string;
+    /** URL of the user's avatar, or `null`. */
+    readonly avatar: string | null;
+    /** The member's server role — `'OWNER'`, `'ADMIN'`, or `'MEMBER'`. */
+    readonly role: 'OWNER' | 'ADMIN' | 'MEMBER';
+    /** The user's current presence status. */
+    readonly status: 'ONLINE' | 'IDLE' | 'DND' | 'OFFLINE';
+    /** `true` if this member is a bot account. */
+    readonly isBot: boolean;
+    /** When this user joined the server. */
+    readonly joinedAt: Date;
+    private readonly _members;
+    constructor(raw: Member, serverId: string, members: MembersAPI);
+    /** `true` if this member is the server owner. */
+    isOwner(): boolean;
+    /** `true` if this member is an admin or the server owner. */
+    isAdmin(): boolean;
+    /** `true` if this member is a regular (non-privileged) member. */
+    isRegularMember(): boolean;
+    /** `true` if the user is currently online. */
+    isOnline(): boolean;
+    /** `true` if the user is idle / away. */
+    isIdle(): boolean;
+    /** `true` if the user is set to Do Not Disturb. */
+    isDND(): boolean;
+    /** `true` if the user appears offline. */
+    isOffline(): boolean;
+    /**
+     * Kick this member from the server.
+     * Bots cannot kick owners or admins (throws 403).
+     *
+     * @example
+     * await member.kick()
+     */
+    kick(): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Ban this member from the server with an optional reason.
+     * Bots cannot ban owners or admins (throws 403).
+     *
+     * @example
+     * await member.ban('Repeated rule violations')
+     */
+    ban(reason?: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Send this user a direct message.
+     * Requires the `messages.write` scope.
+     *
+     * @example
+     * await member.dm('Welcome to the server!')
+     * await member.dm({ content: 'Hello', embed: { title: 'Rules' } })
+     */
+    dm(options: string | Omit<SendMessageOptions, 'replyToId'>): Promise<Message>;
+    /**
+     * Assign a custom role to this member.
+     * Requires the `members.roles` scope.
+     *
+     * @example
+     * await member.addRole('role-id')
+     */
+    addRole(roleId: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Remove a custom role from this member.
+     * Requires the `members.roles` scope.
+     *
+     * @example
+     * await member.removeRole('role-id')
+     */
+    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`.
+     */
+    toString(): string;
+    /** Returns the raw member data. */
+    toJSON(): Member;
+}
+
+/**
+ * A rich wrapper around a raw `Role` with convenience methods.
+ *
+ * Returned by `client.fetchRole()` and `client.fetchRoles()`.
+ *
+ * @example
+ * const roles = await client.fetchRoles('server-id')
+ * const mod = roles.find(r => r.name === 'Moderator')
+ * if (mod) await mod.assign('user-id')
+ */
+declare class NovaRole {
+    /** Unique role ID. */
+    readonly id: string;
+    /** Display name of the role. */
+    readonly name: string;
+    /** Hex colour string (e.g. `'#00d4ff'`), or `null` for no colour. */
+    readonly color: string | null;
+    /** Sort position — lower numbers appear higher in the role list. */
+    readonly position: number;
+    /** The server this role belongs to. */
+    readonly serverId: string;
+    /** Whether this role is displayed separately in the member sidebar. */
+    readonly hoist: boolean;
+    /** When the role was created. */
+    readonly createdAt: Date;
+    private readonly _roles;
+    constructor(raw: Role, roles: RolesAPI);
+    /**
+     * Edit this role's name, colour, hoist flag, or permissions.
+     *
+     * @example
+     * await role.edit({ color: '#ff0000', name: 'Red Team' })
+     */
+    edit(options: RoleEditOptions): Promise<Role>;
+    /**
+     * Delete this role from the server.
+     * Any members currently assigned this role will have it removed.
+     *
+     * @example
+     * await role.delete()
+     */
+    delete(): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Assign this role to a server member.
+     *
+     * @example
+     * await role.assign('user-id')
+     */
+    assign(userId: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Remove this role from a server member.
+     *
+     * @example
+     * await role.remove('user-id')
+     */
+    remove(userId: string): Promise<{
+        ok: true;
+    }>;
+    /** Returns `true` if the role has a custom hex colour set. */
+    hasColor(): boolean;
+    /** Returns the CSS-safe hex colour string. Falls back to `'#99aab5'` (grey). */
+    toHex(): string;
+    toJSON(): Role;
+}
+
+/**
+ * A rich wrapper around a raw `NovaServer` with convenience methods.
+ *
+ * Returned by `client.fetchServer()` and `client.fetchServers()`.
+ *
+ * @example
+ * const server = await client.fetchServer('server-id')
+ * console.log(`${server.name} — ${server.memberCount} members`)
+ * await server.send('welcome-channel-id', 'Bot is online! 🤖')
+ */
+declare class NovaServerWrapper {
+    /** Unique server ID. */
+    readonly id: string;
+    /** Server display name. */
+    readonly name: string;
+    /** URL to the server icon, or `null`. */
+    readonly icon: string | null;
+    /** Short description of the server, or `null`. */
+    readonly description: string | null;
+    /** Total member count at time of fetch. */
+    readonly memberCount: number;
+    /** Total channel count at time of fetch. */
+    readonly channelCount: number;
+    /** When the bot joined this server. */
+    readonly joinedAt: Date;
+    private readonly _servers;
+    private readonly _channels;
+    private readonly _members;
+    private readonly _invites;
+    private readonly _roles;
+    private readonly _messages;
+    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.
+     *
+     * @example
+     * await server.update({ name: 'New Name' })
+     */
+    update(options: ServerUpdateOptions): Promise<NovaServer>;
+    /**
+     * Fetch all channels in this server.
+     *
+     * @example
+     * const channels = await server.fetchChannels()
+     * const text = channels.filter(c => c.type === 'TEXT')
+     */
+    fetchChannels(): Promise<Channel[]>;
+    /**
+     * Create a new channel in this server.
+     * Requires the `channels.manage` scope.
+     *
+     * @example
+     * const ch = await server.createChannel({ name: 'bot-logs', type: 'TEXT' })
+     */
+    createChannel(options: CreateChannelOptions): Promise<Channel>;
+    /**
+     * Fetch members in this server.
+     *
+     * @example
+     * const members = await server.fetchMembers({ limit: 100 })
+     */
+    fetchMembers(options?: FetchMembersOptions): Promise<Member[]>;
+    /**
+     * Fetch a single member by user ID.
+     *
+     * @example
+     * const member = await server.fetchMember('user-id')
+     */
+    fetchMember(userId: string): ReturnType<MembersAPI['fetch']>;
+    /**
+     * Kick a member from this server.
+     *
+     * @example
+     * await server.kick('user-id')
+     */
+    kick(userId: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Ban a member from this server.
+     *
+     * @example
+     * await server.ban('user-id', 'Spamming')
+     */
+    ban(userId: string, reason?: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Fetch the ban list for this server.
+     */
+    fetchBans(): Promise<BanEntry[]>;
+    /**
+     * 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.
+     *
+     * @example
+     * const invites = await server.fetchInvites()
+     */
+    fetchInvites(): Promise<Invite[]>;
+    /**
+     * Create an invite for this server.
+     *
+     * @example
+     * const invite = await server.createInvite({ maxUses: 10 })
+     * console.log(`https://novachatapp.com/invite/${invite.code}`)
+     */
+    createInvite(options?: InviteCreateOptions): Promise<Invite>;
+    /**
+     * Send a message to a channel in this server by channel ID.
+     *
+     * @example
+     * 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;
+}
+
+/**
+ * A rich wrapper around a raw `Invite` with convenience methods.
+ *
+ * Returned by `client.fetchInvite()` and `client.fetchInvites()`.
+ *
+ * @example
+ * const invite = await client.fetchInvite('abc123')
+ * if (invite.isExpired()) await invite.revoke()
+ */
+declare class NovaInvite {
+    /** The invite code — appended to `https://novachatapp.com/invite/`. */
+    readonly code: string;
+    /** The server this invite grants access to. */
+    readonly serverId: string;
+    /** The user ID of whoever created this invite. */
+    readonly creatorId: string;
+    /** How many times this invite has been used. */
+    readonly uses: number;
+    /** Maximum allowed uses before the invite deactivates. `null` = unlimited. */
+    readonly maxUses: number | null;
+    /** When the invite expires. `null` = never expires. */
+    readonly expiresAt: Date | null;
+    /** When the invite was created. */
+    readonly createdAt: Date;
+    private readonly _invites;
+    constructor(raw: Invite, invites: InvitesAPI);
+    /** The full URL users can follow to join the server. */
+    get url(): string;
+    /**
+     * Returns `true` if the invite has passed its expiry time.
+     * Always `false` for invites with no expiry.
+     */
+    isExpired(): boolean;
+    /**
+     * Returns `true` if the invite has reached its maximum use count.
+     * Always `false` for unlimited invites.
+     */
+    isExhausted(): boolean;
+    /** Whether this invite is still usable (not expired and not exhausted). */
+    isValid(): boolean;
+    /**
+     * Revoke (delete) this invite, making the code unusable.
+     * Requires the `invites.manage` scope.
+     *
+     * @example
+     * await invite.revoke()
+     */
+    revoke(): Promise<{
+        ok: true;
+    }>;
+    toJSON(): Invite;
+}
+
+/**
+ * A rich wrapper around a raw `Webhook` with convenience methods.
+ *
+ * Returned by `client.fetchWebhook()` and `client.fetchWebhooks()`.
+ *
+ * @example
+ * const webhook = await client.fetchWebhook('webhook-id')
+ * await webhook.execute({ content: '🚀 Build passed!', username: 'CI Bot' })
+ */
+declare class NovaWebhook {
+    /** Unique webhook ID. */
+    readonly id: string;
+    /** The server this webhook belongs to. */
+    readonly serverId: string;
+    /** The channel messages are posted to when this webhook is executed. */
+    readonly channelId: string;
+    /** Display name shown next to messages posted via this webhook. */
+    readonly name: string;
+    /** Secret token — required to execute the webhook via HTTP. */
+    readonly token: string;
+    /** When the webhook was created. */
+    readonly createdAt: Date;
+    private readonly _webhooks;
+    constructor(raw: Webhook, webhooks: WebhooksAPI);
+    /**
+     * Edit this webhook's name or target channel.
+     * Requires the `webhooks.manage` scope.
+     *
+     * @example
+     * await webhook.edit({ name: 'New Name', channelId: 'other-channel-id' })
+     */
+    edit(options: WebhookEditOptions): Promise<Webhook>;
+    /**
+     * Delete this webhook.
+     * Requires the `webhooks.manage` scope.
+     *
+     * @example
+     * await webhook.delete()
+     */
+    delete(): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Post a message via this webhook.
+     *
+     * @example
+     * await webhook.execute({ content: '❌ Tests failed on branch main', username: 'CI' })
+     */
+    execute(options: ExecuteWebhookOptions): Promise<Message>;
+    toJSON(): Webhook;
+}
+
+/**
+ * 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);
+    /**
+     * Edit this forum post.
+     *
+     * @example
+     * await post.edit({ title: 'Updated title' })
+     */
+    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;
+}
+
+/**
+ * Function called when a value is emitted.
+ */
+type Observer<T> = (value: T) => void;
+/**
+ * A function that transforms one EventStream into another.
+ * Used with the `pipe()` operator.
+ */
+type OperatorFn<T, U> = (stream: EventStream<T>) => EventStream<U>;
+/**
+ * Represents an active subscription to an `EventStream`.
+ * Call `.unsubscribe()` to cancel delivery and free resources.
+ *
+ * @example
+ * const sub = client.stream('messageCreate').subscribe(msg => console.log(msg.content))
+ * // Later:
+ * sub.unsubscribe()
+ */
+declare class Subscription {
+    private readonly _teardown;
+    private _closed;
+    constructor(teardown: () => void);
+    /** `true` once `unsubscribe()` has been called. */
+    get closed(): boolean;
+    /** Cancel the subscription. Safe to call multiple times. */
+    unsubscribe(): void;
+}
+/**
+ * A lazy, composable reactive stream — like RxJS `Observable` but zero-dependency.
+ *
+ * Streams are **cold** by default: the source function runs fresh for each
+ * `subscribe()` call. When created by `client.stream()` they become effectively
+ * **hot**, sharing the same underlying gateway event source.
+ *
+ * @example
+ * // Filter messages in a specific channel and debounce rapid edits
+ * client.stream('messageCreate')
+ *   .filter(msg => msg.channelId === '123')
+ *   .debounce(500)
+ *   .subscribe(msg => console.log('New message:', msg.content))
+ *
+ * // Collect the next 5 pings, then stop
+ * const pings = await client.stream('messageCreate')
+ *   .filter(msg => msg.content === '!ping')
+ *   .collect(5)
+ */
+declare class EventStream<T> {
+    /** @internal Source function — called once per `subscribe()`. */
+    readonly _source: (observer: Observer<T>) => () => void;
+    constructor(
+    /** @internal Source function — called once per `subscribe()`. */
+    _source: (observer: Observer<T>) => () => void);
+    /**
+     * Activate the stream and receive values via `fn`.
+     * Returns a `Subscription` — call `.unsubscribe()` to stop delivery.
+     *
+     * @example
+     * const sub = stream.subscribe(value => console.log(value))
+     * // later…
+     * sub.unsubscribe()
+     */
+    subscribe(fn: Observer<T>): Subscription;
+    /**
+     * Only pass values that satisfy `predicate`.
+     *
+     * @example
+     * stream.filter(msg => msg.content.startsWith('!'))
+     */
+    filter(predicate: (value: T) => boolean): EventStream<T>;
+    /**
+     * Transform each value with `transform`.
+     *
+     * @example
+     * stream.map(msg => msg.content.toUpperCase())
+     */
+    map<U>(transform: (value: T) => U): EventStream<U>;
+    /**
+     * Map each value to an inner stream and flatten the results.
+     *
+     * @example
+     * client.stream('messageCreate')
+     *   .flatMap(msg => client.stream('reactionAdd').filter(r => r.messageId === msg.id))
+     */
+    flatMap<U>(transform: (value: T) => EventStream<U>): EventStream<U>;
+    /**
+     * Stop after emitting `count` values.
+     *
+     * @example
+     * stream.take(1).subscribe(first => console.log('First:', first))
+     */
+    take(count: number): EventStream<T>;
+    /**
+     * Skip the first `count` values.
+     *
+     * @example
+     * stream.skip(3) // ignore the first 3
+     */
+    skip(count: number): EventStream<T>;
+    /**
+     * Emit values while `predicate` returns `true`, then auto-unsubscribe.
+     *
+     * @example
+     * stream.takeWhile(n => n < 10)
+     */
+    takeWhile(predicate: (value: T) => boolean): EventStream<T>;
+    /**
+     * Stop emitting once `signal` resolves.
+     *
+     * @example
+     * const stop = new Promise(resolve => setTimeout(resolve, 5_000))
+     * stream.takeUntil(stop).subscribe(handler)
+     */
+    takeUntil(signal: Promise<unknown>): EventStream<T>;
+    /**
+     * Delay forwarding by `ms`. If a new value arrives before the delay expires
+     * the timer resets — only the last value within a quiet period passes.
+     * Useful for suppressing bursts.
+     *
+     * @example
+     * client.stream('typingStart').debounce(300).subscribe(onTyping)
+     */
+    debounce(ms: number): EventStream<T>;
+    /**
+     * Forward a value at most once per `ms` milliseconds (leading-edge).
+     *
+     * @example
+     * client.stream('reactionAdd').throttle(1_000).subscribe(alert)
+     */
+    throttle(ms: number): EventStream<T>;
+    /**
+     * Collect emitted values into windows of `windowMs` milliseconds and emit
+     * each window as an array. Empty windows are skipped.
+     *
+     * @example
+     * // Count messages per second
+     * client.stream('messageCreate').windowTime(1_000).subscribe(batch => {
+     *   console.log(`${batch.length} msgs in last second`)
+     * })
+     */
+    windowTime(windowMs: number): EventStream<T[]>;
+    /**
+     * Merge another stream into this one.
+     *
+     * @example
+     * streamA.merge(streamB).subscribe(handler)
+     */
+    merge(other: EventStream<T>): EventStream<T>;
+    /**
+     * Emit a `[T, U]` tuple each time EITHER stream fires,
+     * pairing with the most recent value from the other stream.
+     * Requires both streams to have emitted at least one value.
+     *
+     * @example
+     * positionStream.combineLatest(speedStream).subscribe(([pos, speed]) => …)
+     */
+    combineLatest<U>(other: EventStream<U>): EventStream<[T, U]>;
+    /**
+     * Resolve with the first value that satisfies an optional `predicate`,
+     * then automatically unsubscribe.
+     *
+     * @example
+     * const welcome = await client.stream('messageCreate')
+     *   .filter(m => m.content === 'hello')
+     *   .first()
+     */
+    first(predicate?: (value: T) => boolean): Promise<T>;
+    /**
+     * Collect exactly `count` values and resolve with them as an array.
+     *
+     * @example
+     * const next3 = await client.stream('messageCreate').collect(3)
+     */
+    collect(count: number): Promise<T[]>;
+    /**
+     * Apply a sequence of operators left-to-right.
+     * Each operator is a function `(EventStream<In>) => EventStream<Out>`.
+     *
+     * @example
+     * const dedupFilter = (s: EventStream<string>) =>
+     *   s.filter(v => v.length > 0)
+     *
+     * stream
+     *   .pipe(dedupFilter, s => s.take(10))
+     *   .subscribe(console.log)
+     */
+    pipe<A>(op1: OperatorFn<T, A>): EventStream<A>;
+    pipe<A, B>(op1: OperatorFn<T, A>, op2: OperatorFn<A, B>): EventStream<B>;
+    pipe<A, B, C>(op1: OperatorFn<T, A>, op2: OperatorFn<A, B>, op3: OperatorFn<B, C>): EventStream<C>;
+    pipe<A, B, C, D>(op1: OperatorFn<T, A>, op2: OperatorFn<A, B>, op3: OperatorFn<B, C>, op4: OperatorFn<C, D>): EventStream<D>;
+    /**
+     * Consume the stream with `for await…of`.
+     *
+     * @example
+     * for await (const msg of client.stream('messageCreate').take(10)) {
+     *   await msg.reply('Got it')
+     * }
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+    /**
+     * Emit a fixed list of values synchronously on subscribe, then complete.
+     */
+    static of<T>(...values: T[]): EventStream<T>;
+    /**
+     * Emit an incrementing counter every `ms` milliseconds.
+     *
+     * @example
+     * EventStream.interval(1_000).take(10).subscribe(n => console.log('tick', n))
+     */
+    static interval(ms: number): EventStream<number>;
+    /**
+     * Merge multiple streams into one.
+     *
+     * @example
+     * EventStream.merge(streamA, streamB).subscribe(handler)
+     */
+    static merge<T>(...streams: EventStream<T>[]): EventStream<T>;
+    /**
+     * Create a hot stream from any Node.js-style `EventEmitter`.
+     *
+     * @example
+     * EventStream.fromEmitter<string>(process, 'message').subscribe(console.log)
+     */
+    static fromEmitter<T>(emitter: {
+        on(event: string, listener: (v: T) => void): unknown;
+        off(event: string, listener: (v: T) => void): unknown;
+    }, event: string): EventStream<T>;
+}
+
+interface EventBufferOptions {
+    /**
+     * Maximum number of events to retain in the ring buffer.
+     * When full, the oldest item is discarded to make room for the newest.
+     * Default: `100`.
+     */
+    size?: number;
+}
+/**
+ * A fixed-size ring buffer that captures events from a `NovaClient` event type
+ * and lets you replay them to new subscribers at any time.
+ *
+ * Obtained via `client.buffer(event, options)` — do **not** construct directly.
+ *
+ * @example
+ * // Start capturing messages (call once, before connect or early in ready)
+ * const msgBuffer = client.buffer('messageCreate', { size: 200 })
+ *
+ * // Later — replay everything received so far, then keep streaming
+ * msgBuffer.asStream({ replay: true }).subscribe(msg => {
+ *   console.log('[replayed or live]', msg.content)
+ * })
+ *
+ * // Quickly inspect the last 10 messages without subscribing
+ * const recent = msgBuffer.getLast(10)
+ *
+ * // Use with async iterator
+ * for await (const msg of msgBuffer.asStream({ replay: true })) {
+ *   if (msg.content === 'stop') break
+ * }
+ */
+declare class EventBuffer<T> {
+    private readonly _ring;
+    private readonly _maxSize;
+    private readonly _observers;
+    constructor(options?: EventBufferOptions);
+    /**
+     * @internal
+     * Called by `NovaClient._deliverEvent()` each time the event fires.
+     * Push to ring buffer and notify live subscribers.
+     */
+    _push(item: T): void;
+    /** All buffered items, oldest first. Never mutate the returned array. */
+    getAll(): T[];
+    /**
+     * The N most recent items.
+     *
+     * @example
+     * const last5 = buffer.getLast(5)
+     */
+    getLast(n: number): T[];
+    /** The most recently buffered item, or `undefined` if the buffer is empty. */
+    get latest(): T | undefined;
+    /** Number of items currently stored. */
+    get size(): number;
+    /** Maximum number of items the buffer can hold. */
+    get capacity(): number;
+    /** `true` when no items are stored. */
+    get isEmpty(): boolean;
+    /** Whether the buffer is at maximum capacity. */
+    get isFull(): boolean;
+    /** Remove all buffered items without affecting active subscriptions. */
+    clear(): void;
+    /**
+     * Expose the buffer as an `EventStream`, giving access to all chaining
+     * operators (`.filter()`, `.map()`, `.debounce()`, etc.).
+     *
+     * Pass `{ replay: true }` to emit all currently buffered items to the
+     * subscriber **before** switching to live delivery.
+     *
+     * @example
+     * // Replay + live with filter
+     * buffer
+     *   .asStream({ replay: true })
+     *   .filter(msg => msg.channelId === '123')
+     *   .subscribe(msg => console.log(msg.content))
+     */
+    asStream(options?: {
+        replay?: boolean;
+    }): EventStream<T>;
+    /**
+     * Subscribe directly, with optional replay.
+     * Equivalent to `.asStream(options).subscribe(fn)`.
+     *
+     * @example
+     * buffer.subscribe(msg => handle(msg), { replay: true })
+     */
+    subscribe(fn: Observer<T>, options?: {
+        replay?: boolean;
+    }): Subscription;
+    /**
+     * Iterate over all **currently buffered** items synchronously.
+     *
+     * @example
+     * for (const msg of buffer) {
+     *   console.log(msg.content)
+     * }
+     */
+    [Symbol.iterator](): Iterator<T>;
+}
+
+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;
+    }) => void;
+    /** A member received or lost a custom role. */
+    memberRoleAdded: (data: {
+        serverId: string;
+        userId: string;
+        roleId: string;
+    }) => void;
+    memberRoleRemoved: (data: {
+        serverId: string;
+        userId: string;
+        roleId: string;
+    }) => void;
+    /** A member's profile data was updated. */
+    memberUpdate: (data: {
+        userId: string;
+        serverId: string;
+    }) => void;
+    /** Server metadata (name, icon, etc.) was updated. */
+    serverUpdate: (data: {
+        id: string;
+        name?: string;
+        icon?: string | null;
+        description?: string | null;
+    }) => void;
+    /** An invite was created. */
+    inviteCreate: (invite: Invite) => void;
+    /** An invite was deleted/revoked. */
+    inviteDelete: (data: {
+        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.
+ *
+ * @example
+ * import { NovaClient } from 'nova-bot-sdk'
+ *
+ * const client = new NovaClient({ token: 'nova_bot_...' })
+ *
+ * client.on('ready', (bot) => {
+ *   console.log(`Logged in as ${bot.botUser.username}`)
+ * })
+ *
+ * client.on('interactionCreate', async (interaction) => {
+ *   if (interaction.commandName === 'ping') {
+ *     await client.interactions.respond(interaction.id, { content: 'Pong!' })
+ *   }
+ * })
+ *
+ * await client.connect()
+ */
+declare class NovaClient extends EventEmitter {
+    /** The authenticated bot application. Available after `ready` fires. */
+    botUser: BotApplication | null;
+    /** Send, edit, delete and fetch messages. */
+    readonly messages: MessagesAPI;
+    /** Register and manage slash, prefix, and context menu commands. */
+    readonly commands: CommandsAPI;
+    /** List, kick, ban, and DM server members. */
+    readonly members: MembersAPI;
+    /** List and update servers the bot is a member of. */
+    readonly servers: ServersAPI;
+    /** Acknowledge and respond to interactions. */
+    readonly interactions: InteractionsAPI;
+    /** Query the bot's effective permissions within a server, channel, or role scope. */
+    readonly permissions: PermissionsAPI;
+    /** Create, edit, and delete channels; fetch pins and messages. */
+    readonly channels: ChannelsAPI;
+    /** Add, remove and fetch reactions on messages. */
+    readonly reactions: ReactionsAPI;
+    /** Create, edit, delete and assign custom roles. */
+    readonly roles: RolesAPI;
+    /** Create, fetch and revoke server invites. */
+    readonly invites: InvitesAPI;
+    /** Create, edit, delete and execute webhooks. */
+    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;
+    private _cronTimers;
+    private readonly _commandHandlers;
+    private readonly _buttonHandlers;
+    private readonly _selectHandlers;
+    private readonly _modalHandlers;
+    private readonly _autocompleteHandlers;
+    private readonly _middlewares;
+    private readonly _streamListeners;
+    private readonly _bufferInstances;
+    constructor(options: NovaClientOptions);
+    /**
+     * Register a handler for a slash or prefix command by name.
+     * Automatically routes `interactionCreate` events whose `commandName` matches.
+     *
+     * @example
+     * client.command('ping', async (interaction) => {
+     *   await interaction.reply('Pong! 🏓')
+     * })
+     */
+    command(name: string, handler: (interaction: NovaInteraction) => unknown): this;
+    /**
+     * Register a handler for a button by its `customId`.
+     *
+     * @example
+     * client.button('confirm_delete', async (interaction) => {
+     *   await interaction.replyEphemeral('Deleted.')
+     * })
+     */
+    button(customId: string, handler: (interaction: NovaInteraction) => unknown): this;
+    /**
+     * Register a handler for a select menu by its `customId`.
+     *
+     * @example
+     * client.selectMenu('colour_pick', async (interaction) => {
+     *   const chosen = interaction.values[0]
+     *   await interaction.reply(`You picked: ${chosen}`)
+     * })
+     */
+    selectMenu(customId: string, handler: (interaction: NovaInteraction) => unknown): this;
+    /**
+     * Register a handler for a modal submission by its `customId`.
+     * Called automatically when the user submits a modal with that `customId`.
+     *
+     * @example
+     * client.modal('report_modal', async (interaction) => {
+     *   const reason = interaction.modalData.reason
+     *   await interaction.replyEphemeral(`Report received: ${reason}`)
+     * })
+     */
+    modal(customId: string, handler: (interaction: NovaInteraction) => unknown): this;
+    /**
+     * Register a handler for an autocomplete interaction by command name.
+     * Called when the user is typing in an option with `autocomplete: true`.
+     * The handler receives the interaction with `interaction.autocomplete.value`
+     * containing the partial text, and should call `interaction.respondAutocomplete()`
+     * to send completion suggestions.
+     *
+     * @example
+     * client.autocomplete('search', async (interaction) => {
+     *   const query = interaction.autocomplete?.value ?? ''
+     *   const results = await myDB.search(query)
+     *   await interaction.respondAutocomplete(
+     *     results.map(r => ({ name: r.label, value: r.id }))
+     *   )
+     * })
+     */
+    autocomplete(commandName: string, handler: (interaction: NovaInteraction) => unknown): this;
+    /** Remove a slash/prefix command handler previously registered with `command()`. */
+    removeCommand(name: string): void;
+    /** Remove a button handler previously registered with `button()`. */
+    removeButton(customId: string): void;
+    /** Remove a select-menu handler previously registered with `selectMenu()`. */
+    removeSelectMenu(customId: string): void;
+    /** Remove a modal handler previously registered with `modal()`. */
+    removeModal(customId: string): void;
+    /** Remove an autocomplete handler previously registered with `autocomplete()`. */
+    removeAutocomplete(name: string): void;
+    /**
+     * Remove a middleware function that was added via `use()`.
+     * This is a reference-equality check — pass the exact same function object.
+     */
+    removeMiddleware(fn: (event: string, payload: unknown, next: (p: unknown) => void) => void): void;
+    emit(event: string | symbol, ...args: any[]): boolean;
+    private _deliverEvent;
+    /**
+     * Add middleware to the event pipeline.
+     *
+     * Middleware runs **before** any `.on()` listener or stream subscriber.
+     * Call `next(payload)` to continue the chain, passing an optionally modified
+     * payload. Not calling `next` **cancels** the event entirely.
+     *
+     * **Global middleware** (all events):
+     * @example
+     * client.use((event, payload, next) => {
+     *   console.log(`[${event}]`)
+     *   next(payload)           // pass through unchanged
+     * })
+     *
+     * **Per-event typed middleware** (single event):
+     * @example
+     * client.use('messageCreate', (msg, next) => {
+     *   if (msg.isFromBot()) return      // cancel — bots ignored
+     *   next(msg)
+     * })
+     *
+     * **Async middleware** (call next after await):
+     * @example
+     * client.use('interactionCreate', async (interaction, next) => {
+     *   const ok = await checkRateLimit(interaction.userId)
+     *   if (ok) next(interaction)
+     * })
+     */
+    use(fn: (event: string, payload: unknown, next: (p: unknown) => void) => void): this;
+    use<K extends keyof NovaClientEvents>(event: K, fn: (payload: Parameters<NovaClientEvents[K]>[0], next: (p: Parameters<NovaClientEvents[K]>[0]) => void) => void): this;
+    /**
+     * Create a reactive `EventStream` for any client event.
+     *
+     * Streams are **hot** (backed by live gateway events) and support a full
+     * operator library: `.filter()`, `.map()`, `.debounce()`, `.throttle()`,
+     * `.take()`, `.flatMap()`, `.combineLatest()`, `.pipe()`, and more.
+     *
+     * Works with `for await…of` thanks to built-in `[Symbol.asyncIterator]`.
+     *
+     * @example
+     * // Only messages in a specific channel, de-duped over 200 ms
+     * client.stream('messageCreate')
+     *   .filter(msg => msg.channelId === announcementId)
+     *   .debounce(200)
+     *   .subscribe(msg => announce(msg))
+     *
+     * // Collect the next 3 pings as an array
+     * const pings = await client.stream('messageCreate')
+     *   .filter(m => m.content === '!ping')
+     *   .collect(3)
+     *
+     * // Async iteration
+     * for await (const interaction of client.stream('interactionCreate').take(10)) {
+     *   await interaction.reply('Processed')
+     * }
+     *
+     * // combineLatest: pair each new message with the latest reaction event
+     * client.stream('messageCreate')
+     *   .combineLatest(client.stream('reactionAdd'))
+     *   .subscribe(([msg, reaction]) => { … })
+     */
+    stream<K extends keyof NovaClientEvents>(event: K): EventStream<Parameters<NovaClientEvents[K]>[0]>;
+    /**
+     * Start capturing events of `event` in a ring buffer of up to `size` items.
+     * Repeated calls for the same event return the **same** buffer instance.
+     *
+     * Later subscribers can replay all captured events, then continue receiving
+     * live ones — a built-in alternative to Discord.js "message cache".
+     *
+     * @example
+     * // Capture the last 500 messages (call before connect())
+     * const msgs = client.buffer('messageCreate', { size: 500 })
+     *
+     * // After connect — inspect without subscribing
+     * console.log('Buffered so far:', msgs.size)
+     * const latest = msgs.getLast(5)
+     *
+     * // New handler that replays history first, then receives live events
+     * msgs.asStream({ replay: true })
+     *   .filter(m => m.content.includes('@everyone'))
+     *   .subscribe(handleMention)
+     *
+     * // Clear the buffer (e.g. when rolling over to a new session)
+     * msgs.clear()
+     */
+    buffer<K extends keyof NovaClientEvents>(event: K, options?: {
+        size?: number;
+    }): EventBuffer<Parameters<NovaClientEvents[K]>[0]>;
+    /**
+     * Connect to the Nova WebSocket gateway.
+     * Resolves when the `ready` event is received.
+     *
+     * @example
+     * await client.connect()
+     */
+    connect(): Promise<void>;
+    /**
+     * Register a recurring task that fires at a set interval.
+     * All cron tasks are automatically cancelled on `disconnect()`.
+     *
+     * @param intervalMs - How often to run the task (in milliseconds).
+     * @param fn         - Async or sync function to call on each tick.
+     * @returns A cancel function — call it to stop this specific task.
+     *
+     * @example
+     * // Check for new announcements every 30 seconds
+     * client.cron(30_000, async () => {
+     *   const messages = await client.messages.fetch(channelId, { limit: 5 })
+     *   // do something...
+     * })
+     */
+    cron(intervalMs: number, fn: () => unknown): () => void;
+    /**
+     * Set the bot's presence status.
+     * Broadcasts to all servers the bot is in via WebSocket.
+     *
+     * @example
+     * client.setStatus('DND')     // Do Not Disturb
+     * client.setStatus('IDLE')    // Away
+     * client.setStatus('OFFLINE') // Appear offline
+     * client.setStatus('ONLINE')  // Back online
+     */
+    setStatus(status: BotStatus): void;
+    /**
+     * Fetch a single channel and return it as a rich `NovaChannel` wrapper.
+     *
+     * @example
+     * const channel = await client.fetchChannel('channel-id')
+     * await channel.send('Hello!')
+     */
+    fetchChannel(channelId: string): Promise<NovaChannel>;
+    /**
+     * Fetch all channels in a server and return them as `NovaChannel` wrappers.
+     *
+     * @example
+     * const channels = await client.fetchChannels('server-id')
+     * const textChannels = channels.filter(c => c.isText())
+     */
+    fetchChannels(serverId: string): Promise<NovaChannel[]>;
+    /**
+     * Fetch all members in a server and return them as `NovaMember` wrappers.
+     *
+     * @example
+     * const members = await client.fetchMembers('server-id')
+     * const bots = members.filter(m => m.isBot)
+     */
+    fetchMembers(serverId: string): Promise<NovaMember[]>;
+    /**
+     * Fetch a single member from a server and return them as a `NovaMember` wrapper.
+     * Uses the dedicated single-member endpoint (more efficient than listing all members).
+     *
+     * @example
+     * const member = await client.fetchMember('server-id', 'user-id')
+     * 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`.
+     *
+     * @example
+     * const server = await client.fetchServer('server-id')
+     * console.log(`${server.name} — ${server.memberCount} members`)
+     */
+    fetchServer(serverId: string): Promise<NovaServerWrapper>;
+    /**
+     * Fetch all servers the bot is in and return them as `NovaServerWrapper` objects.
+     *
+     * @example
+     * const servers = await client.fetchServers()
+     * for (const s of servers) console.log(s.name)
+     */
+    fetchServers(): Promise<NovaServerWrapper[]>;
+    /**
+     * Fetch all custom roles in a server and return them as `NovaRole` wrappers.
+     *
+     * @example
+     * const roles = await client.fetchRoles('server-id')
+     * const mod = roles.find(r => r.name === 'Moderator')
+     */
+    fetchRoles(serverId: string): Promise<NovaRole[]>;
+    /**
+     * Fetch all active invites for a server and return them as `NovaInvite` wrappers.
+     *
+     * @example
+     * const invites = await client.fetchInvites('server-id')
+     * const active = invites.filter(i => i.isValid())
+     */
+    fetchInvites(serverId: string): Promise<NovaInvite[]>;
+    /**
+     * Fetch a single invite by code and return it as a `NovaInvite` wrapper.
+     *
+     * @example
+     * const invite = await client.fetchInvite('abc123')
+     * if (invite.isExpired()) await invite.revoke()
+     */
+    fetchInvite(code: string): Promise<NovaInvite>;
+    /**
+     * Fetch all webhooks in a channel and return them as `NovaWebhook` wrappers.
+     *
+     * @example
+     * const webhooks = await client.fetchWebhooks('channel-id')
+     */
+    fetchWebhooks(channelId: string): Promise<NovaWebhook[]>;
+    /**
+     * Fetch a single webhook by ID and return it as a `NovaWebhook` wrapper.
+     *
+     * @example
+     * const webhook = await client.fetchWebhook('webhook-id')
+     * await webhook.execute({ content: 'Build passed! ✅' })
+     */
+    fetchWebhook(webhookId: string): Promise<NovaWebhook>;
+    /**
+     * Fetch forum posts from a FORUM channel and return them as `NovaForumPost` wrappers.
+     *
+     * @example
+     * 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.
+     *
+     * @example
+     * const upcoming = await client.fetchEvents('server-id', { upcoming: true })
+     * for (const event of upcoming) console.log(event.title)
+     */
+    fetchEvents(serverId: string, options?: FetchEventsOptions): Promise<NovaServerEvent[]>;
+    /**
+     * 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!' })
+     */
+    fetchEvent(eventId: string): Promise<NovaServerEvent>;
+    /**
+     * Fetch a user's public profile.
+     *
+     * @example
+     * const user = await client.fetchUserProfile('user-id')
+     * console.log(user.bio)
+     */
+    fetchUserProfile(userId: string): Promise<UserProfile>;
+    /**
+     * 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`))
+     */
+    fetchLeaderboard(serverId: string, limit?: number): Promise<LeaderboardEntry[]>;
+    /**
+     * Fetch warnings in a server, optionally filtered by user.
+     *
+     * @example
+     * const warnings = await client.fetchWarnings('server-id', { userId: 'user-id' })
+     */
+    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;
+    off(event: string | symbol, listener: (...args: unknown[]) => void): this;
+}
+
+export { type EventBufferOptions as $, type Attachment as A, type BanEntry as B, type ChannelCategory as C, type BotEventType as D, type EmbedField as E, type BotModalDefinition as F, type BotModalField as G, type BotPermissionRecord as H, type InviteCreateOptions as I, type BotStatus as J, type BotUser as K, type BulkDeleteResult as L, type MessageComponent as M, NovaMessage as N, type Channel as O, ChannelsAPI as P, CommandsAPI as Q, type RoleCreateOptions as R, type SlashCommandOption as S, type CreateCategoryOptions as T, type DirectMessage as U, type EditAutoModRuleOptions as V, type EditChannelOptions as W, type EditEventOptions as X, type EditForumPostOptions as Y, type EditMessageOptions as Z, EventBuffer as _, type Embed as a, type VoiceState as a$, EventsAPI as a0, type ExecuteWebhookOptions as a1, type FetchAuditLogsOptions as a2, type FetchChannelsOptions as a3, type FetchEventsOptions as a4, type FetchForumPostsOptions as a5, type FetchMembersOptions as a6, type FetchMessagesOptions as a7, type FetchWarningsOptions as a8, ForumAPI as a9, PermissionsAPI as aA, type PermissionsQueryOptions as aB, type PermissionsResult as aC, type PollInteractionsOptions as aD, type PrefixCommandDefinition as aE, type Reaction as aF, type ReactionDetail as aG, ReactionsAPI as aH, type RegisteredContextCommand as aI, type RegisteredPrefixCommand as aJ, type RegisteredSlashCommand as aK, type RespondInteractionOptions as aL, type Role as aM, type RoleEditOptions as aN, RolesAPI as aO, type ServerEvent as aP, type ServerEventAttendee as aQ, type ServerStats as aR, type ServerUpdateOptions as aS, ServersAPI as aT, type SingleMember as aU, type SoundboardClip as aV, Subscription as aW, TextInputBuilder as aX, type TextInputStyle as aY, type UserProfile as aZ, UsersAPI as a_, type ForumPost as aa, HttpClient as ab, type Interaction as ac, InteractionOptions as ad, type InteractionType as ae, type Invite as af, InvitesAPI as ag, type LeaderboardEntry as ah, type Member as ai, type MemberXPData as aj, MembersAPI as ak, type Message as al, NovaBan as am, NovaChannel as an, type NovaClientOptions as ao, NovaForumPost as ap, NovaInvite as aq, NovaMember as ar, NovaRole as as, type NovaServer as at, NovaServerEvent as au, NovaServerWrapper as av, NovaWarning as aw, NovaWebhook as ax, type Observer as ay, type OperatorFn as az, type SlashCommandDefinition as b, type Warning as b0, type Webhook as b1, type WebhookCreateOptions as b2, type WebhookEditOptions as b3, WebhooksAPI as b4, type SendMessageOptions as c, CategoriesAPI as d, type EditCategoryOptions as e, type CreateForumPostOptions as f, type CreateEventOptions as g, type ChannelType as h, type CreateChannelOptions as i, type CreateAutoModRuleOptions as j, type ContextCommandDefinition as k, NovaInteraction as l, MessagesAPI as m, InteractionsAPI as n, EventStream as o, NovaClient as p, ModalBuilder as q, type NovaClientEvents as r, AuditLogAPI as s, type AuditLogAction as t, type AuditLogEntry as u, AutoModAPI as v, type AutoModRule as w, type AutoModRuleType as x, type BotApplication as y, type BotEvent as z };