novaapp-sdk 1.2.0 → 1.3.0

package/dist/index.d.mts

@@ -68,8 +68,8 @@ interface Channel {
     serverId: string | null;
     topic: string | null;
     position: number;
-    isNsfw: boolean;
-    slowMode: number | null;
+    /** Slow-mode interval in seconds. `0` means disabled. */
+    slowMode: number;
     createdAt: string;
 }
 interface Role {
@@ -336,14 +336,12 @@ interface CreateChannelOptions {
     type?: ChannelType;
     topic?: string;
     position?: number;
-    isNsfw?: boolean;
     slowMode?: number;
 }
 interface EditChannelOptions {
     name?: string;
     topic?: string;
     position?: number;
-    isNsfw?: boolean;
     slowMode?: number;
 }
 interface FetchChannelsOptions {
@@ -382,6 +380,29 @@ interface PermissionsQueryOptions {
     /** 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 NovaClientOptions {
     /** Your bot token — starts with "nova_bot_" */
     token: string;
@@ -1333,6 +1354,214 @@ declare class NovaMessage {
     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;
+    constructor(raw: Channel, channels: ChannelsAPI, messages: MessagesAPI);
+    /** `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;
+    }>;
+    /**
+     * 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;
+    }>;
+    /**
+     * Returns a mention-style string: `@displayName`.
+     */
+    toString(): string;
+    /** Returns the raw member data. */
+    toJSON(): Member;
+}
+
 interface NovaClientEvents {
     /** Fired when the bot connects and is identified by the gateway. */
     ready: (bot: BotApplication) => void;
@@ -1396,6 +1625,59 @@ interface NovaClientEvents {
         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: (data: {
+        id: string;
+        name: string;
+        color: string | null;
+        serverId: string;
+        position: number;
+        hoist: boolean;
+        createdAt: string;
+    }) => 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's profile data was updated. */
+    memberUpdate: (data: {
+        userId: string;
+        serverId: string;
+    }) => void;
 }
 /**
  * The main Nova bot client.
@@ -1443,6 +1725,7 @@ declare class NovaClient extends EventEmitter {
     private readonly _commandHandlers;
     private readonly _buttonHandlers;
     private readonly _selectHandlers;
+    private readonly _modalHandlers;
     constructor(options: NovaClientOptions);
     /**
      * Register a handler for a slash or prefix command by name.
@@ -1473,6 +1756,17 @@ declare class NovaClient extends EventEmitter {
      * })
      */
     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;
     /**
      * Connect to the Nova WebSocket gateway.
      * Resolves when the `ready` event is received.
@@ -1508,6 +1802,51 @@ declare class NovaClient extends EventEmitter {
      * 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.
+     * Throws if the user is not found in the server.
+     *
+     * @example
+     * const member = await client.fetchMember('server-id', 'user-id')
+     * await member.dm('Welcome!')
+     */
+    fetchMember(serverId: string, userId: string): Promise<NovaMember>;
+    /**
+     * 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]>;
     /**
      * Disconnect from the gateway and clean up.
      */
@@ -2248,4 +2587,270 @@ declare class Logger {
     commandError(name: string, err: unknown): void;
 }
 
-export { ActionRowBuilder, type Attachment, type BanEntry, type BotApplication, type BotEvent, type BotEventType, type BotModalDefinition, type BotModalField, type BotPermissionRecord, type BotStatus, type BotUser, ButtonBuilder, type ButtonStyle, type Channel, type ChannelType, ChannelsAPI, Collection, CommandsAPI, type ContextCommandDefinition, Cooldown, CooldownManager, type CreateChannelOptions, type EditChannelOptions, type EditMessageOptions, type Embed, EmbedBuilder, type EmbedField, type FetchChannelsOptions, type FetchMembersOptions, type FetchMessagesOptions, HttpClient, type Interaction, InteractionOptions, type InteractionType, InteractionsAPI, type Invite, Logger, type Member, MembersAPI, type Message, MessageBuilder, type MessageComponent, MessagesAPI, ModalBuilder, NovaClient, type NovaClientEvents, type NovaClientOptions, NovaInteraction, NovaMessage, type NovaServer, PermissionsAPI, type PermissionsQueryOptions, type PermissionsResult, PollBuilder, type PollDefinition, type PollInteractionsOptions, type PollOption, type PrefixCommandDefinition, type Reaction, type ReactionDetail, ReactionsAPI, type RegisteredContextCommand, type RegisteredPrefixCommand, type RegisteredSlashCommand, type RespondInteractionOptions, type Role, SelectMenuBuilder, type SelectMenuOption, type SendMessageOptions, ServersAPI, SlashCommandBuilder, type SlashCommandDefinition, type SlashCommandOption, SlashCommandOptionBuilder, TextInputBuilder, type TextInputStyle };
+/**
+ * Async cursor-based paginator for any list API.
+ *
+ * Pass a `fetchFn` that takes the current cursor and returns the next
+ * page of items plus the cursor to use for the next page (`null` = done).
+ *
+ * @example
+ * // Paginate all messages in a channel
+ * const paginator = new Paginator(async (cursor) => {
+ *   const messages = await client.messages.fetch(channelId, { limit: 50, before: cursor ?? undefined })
+ *   return { items: messages, cursor: messages.at(-1)?.id ?? null }
+ * })
+ *
+ * // Lazy async iteration
+ * for await (const message of paginator) {
+ *   console.log(message.content)
+ * }
+ *
+ * // Or collect everything at once
+ * const all = await paginator.fetchAll()
+ */
+declare class Paginator<T> {
+    private readonly fetchFn;
+    private _cursor;
+    private _done;
+    private _totalFetched;
+    constructor(fetchFn: (cursor: string | null) => Promise<{
+        items: T[];
+        cursor: string | null;
+    }>);
+    /** Whether all pages have been consumed. */
+    get done(): boolean;
+    /** Total number of items fetched so far (across all pages). */
+    get totalFetched(): number;
+    /**
+     * Fetch the next page of results.
+     * Returns an empty array when there are no more pages.
+     *
+     * @example
+     * const page1 = await paginator.fetchPage()
+     * const page2 = await paginator.fetchPage()
+     */
+    fetchPage(): Promise<T[]>;
+    /**
+     * Fetch **all** remaining pages and return a flat array.
+     *
+     * ⚠️ Use with caution on very large collections.
+     *
+     * @example
+     * const allMembers = await paginator.fetchAll()
+     */
+    fetchAll(): Promise<T[]>;
+    /**
+     * Fetch up to `n` items total (across however many pages are needed).
+     *
+     * @example
+     * const first100 = await paginator.fetchN(100)
+     */
+    fetchN(n: number): Promise<T[]>;
+    /**
+     * Async-iterate over every item, one page at a time.
+     *
+     * @example
+     * for await (const msg of paginator) {
+     *   process(msg)
+     * }
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<T>;
+    /**
+     * Reset the paginator so you can iterate from the beginning again.
+     *
+     * @example
+     * await paginator.fetchAll()
+     * paginator.reset()
+     * const againFirst = await paginator.fetchPage()
+     */
+    reset(): void;
+}
+
+/**
+ * All known Nova bot permission keys.
+ * Use these as string constants when calling `has()`, `grant()`, etc.
+ */
+declare const Permissions: {
+    /** Read messages in channels. */
+    readonly MESSAGES_READ: "messages.read";
+    /** Send messages in channels. */
+    readonly MESSAGES_WRITE: "messages.write";
+    /** Edit / delete any message (not just the bot's own). */
+    readonly MESSAGES_MANAGE: "messages.manage";
+    /** Create, edit and delete channels. */
+    readonly CHANNELS_MANAGE: "channels.manage";
+    /** Kick members from the server. */
+    readonly MEMBERS_KICK: "members.kick";
+    /** Ban and unban members from the server. */
+    readonly MEMBERS_BAN: "members.ban";
+    /** Assign and remove roles on members. */
+    readonly MEMBERS_ROLES: "members.roles";
+    /** Edit server settings. */
+    readonly SERVERS_MANAGE: "servers.manage";
+};
+type PermissionKey = (typeof Permissions)[keyof typeof Permissions];
+/**
+ * Utility class for working with Nova bot permission records.
+ *
+ * Unlike a Discord-style bitfield, Nova permissions are stored as a
+ * `Record<string, boolean>` map.  `PermissionsBitfield` wraps that
+ * map with readable helpers for checking, merging, and diffing.
+ *
+ * @example
+ * const perms = new PermissionsBitfield({
+ *   'messages.read':  true,
+ *   'messages.write': true,
+ * })
+ *
+ * perms.has('messages.read')          // true
+ * perms.has('channels.manage')        // false
+ * perms.hasAll('messages.read', 'messages.write')  // true
+ * perms.missing('messages.manage', 'members.kick') // ['messages.manage', 'members.kick']
+ * perms.toArray()                     // ['messages.read', 'messages.write']
+ */
+declare class PermissionsBitfield {
+    private readonly _perms;
+    constructor(perms?: Record<string, boolean>);
+    /**
+     * Returns `true` if the given permission is explicitly granted.
+     *
+     * @example
+     * if (!perms.has(Permissions.MESSAGES_WRITE)) {
+     *   throw new Error('Bot cannot write messages here.')
+     * }
+     */
+    has(permission: string): boolean;
+    /**
+     * Returns `true` if **all** listed permissions are granted.
+     *
+     * @example
+     * perms.hasAll('messages.read', 'messages.write') // true
+     */
+    hasAll(...permissions: string[]): boolean;
+    /**
+     * Returns `true` if **at least one** of the listed permissions is granted.
+     *
+     * @example
+     * perms.hasAny('channels.manage', 'servers.manage') // true if either is set
+     */
+    hasAny(...permissions: string[]): boolean;
+    /**
+     * Returns the list of permissions that are **not** granted.
+     *
+     * @example
+     * const missing = perms.missing('messages.write', 'members.kick')
+     * if (missing.length) throw new Error(`Missing: ${missing.join(', ')}`)
+     */
+    missing(...permissions: string[]): string[];
+    /**
+     * Return a **new** `PermissionsBitfield` with the given permission granted.
+     *
+     * @example
+     * const updated = perms.grant('channels.manage')
+     */
+    grant(...permissions: string[]): PermissionsBitfield;
+    /**
+     * Return a **new** `PermissionsBitfield` with the given permission denied.
+     *
+     * @example
+     * const restricted = perms.deny('members.kick')
+     */
+    deny(...permissions: string[]): PermissionsBitfield;
+    /**
+     * Merge another record or `PermissionsBitfield` on top of this one.
+     * The incoming values **override** any existing ones.
+     *
+     * @example
+     * const merged = serverPerms.merge(channelOverrides)
+     */
+    merge(other: Record<string, boolean> | PermissionsBitfield): PermissionsBitfield;
+    /**
+     * Returns an array of the permission keys that are **currently granted**.
+     *
+     * @example
+     * perms.toArray() // ['messages.read', 'messages.write']
+     */
+    toArray(): string[];
+    /**
+     * Returns the raw `Record<string, boolean>` map.
+     */
+    toRecord(): Record<string, boolean>;
+    /**
+     * Pretty-print the granted permissions.
+     *
+     * @example
+     * console.log(String(perms)) // 'PermissionsBitfield[messages.read, messages.write]'
+     */
+    toString(): string;
+    /** Create a `PermissionsBitfield` from an existing record. */
+    static from(perms: Record<string, boolean>): PermissionsBitfield;
+    /** A `PermissionsBitfield` with all known permissions granted. */
+    static readonly ALL: PermissionsBitfield;
+    /** A `PermissionsBitfield` with no permissions granted. */
+    static readonly NONE: PermissionsBitfield;
+}
+
+/**
+ * Returns a promise that resolves after `ms` milliseconds.
+ * Useful in retry loops, cron tasks, and staged sends.
+ *
+ * @example
+ * await sleep(2_000) // wait 2 seconds
+ */
+declare function sleep(ms: number): Promise<void>;
+/**
+ * Wraps a promise with a timeout — rejects with an error if the original
+ * promise does not resolve within `ms` milliseconds.
+ *
+ * @example
+ * const result = await withTimeout(fetchData(), 5_000, 'fetchData took too long')
+ */
+declare function withTimeout<T>(promise: Promise<T>, ms: number, message?: string): Promise<T>;
+/**
+ * Format a duration in milliseconds to a compact human-readable string.
+ *
+ * @example
+ * formatDuration(0)          // '0s'
+ * formatDuration(90_000)     // '1m 30s'
+ * formatDuration(3_661_000)  // '1h 1m 1s'
+ * formatDuration(604_800_000) // '1w'
+ */
+declare function formatDuration(ms: number): string;
+/**
+ * Format a timestamp as a relative human-readable string from now.
+ * Accepts a `Date`, a Unix timestamp (ms), or an ISO date string.
+ *
+ * @example
+ * formatRelative(Date.now() - 5_000)    // 'just now'
+ * formatRelative(Date.now() - 90_000)   // '1 minute ago'
+ * formatRelative(Date.now() + 60_000)   // 'in 1 minute'
+ * formatRelative(Date.now() - 86_400_000) // 'yesterday'
+ */
+declare function formatRelative(timestamp: Date | number | string): string;
+/**
+ * Safely parse any timestamp (ISO string, Unix ms, or Date) to a `Date`.
+ * Returns `null` if the input is nullish or not parseable.
+ *
+ * @example
+ * parseTimestamp('2026-01-01T00:00:00.000Z') // Date
+ * parseTimestamp(null)                        // null
+ */
+declare function parseTimestamp(value: string | number | Date | null | undefined): Date | null;
+/**
+ * Returns the remaining time until a target date as an object with components.
+ * All values are `0` if the target is in the past.
+ *
+ * @example
+ * const { days, hours, minutes, seconds } = countdown(new Date('2027-01-01'))
+ * console.log(`${days}d ${hours}h ${minutes}m ${seconds}s remaining`)
+ */
+declare function countdown(target: Date | number | string): {
+    weeks: number;
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    total: number;
+};
+
+export { ActionRowBuilder, type Attachment, type BanEntry, type BotApplication, type BotEvent, type BotEventType, type BotModalDefinition, type BotModalField, type BotPermissionRecord, type BotStatus, type BotUser, ButtonBuilder, type ButtonStyle, type Channel, type ChannelType, ChannelsAPI, Collection, CommandsAPI, type ContextCommandDefinition, Cooldown, CooldownManager, type CreateChannelOptions, type DirectMessage, type EditChannelOptions, type EditMessageOptions, type Embed, EmbedBuilder, type EmbedField, type FetchChannelsOptions, type FetchMembersOptions, type FetchMessagesOptions, HttpClient, type Interaction, InteractionOptions, type InteractionType, InteractionsAPI, type Invite, Logger, type Member, MembersAPI, type Message, MessageBuilder, type MessageComponent, MessagesAPI, ModalBuilder, NovaChannel, NovaClient, type NovaClientEvents, type NovaClientOptions, NovaInteraction, NovaMember, NovaMessage, type NovaServer, Paginator, type PermissionKey, Permissions, PermissionsAPI, PermissionsBitfield, type PermissionsQueryOptions, type PermissionsResult, PollBuilder, type PollDefinition, type PollInteractionsOptions, type PollOption, type PrefixCommandDefinition, type Reaction, type ReactionDetail, ReactionsAPI, type RegisteredContextCommand, type RegisteredPrefixCommand, type RegisteredSlashCommand, type RespondInteractionOptions, type Role, SelectMenuBuilder, type SelectMenuOption, type SendMessageOptions, ServersAPI, SlashCommandBuilder, type SlashCommandDefinition, type SlashCommandOption, SlashCommandOptionBuilder, TextInputBuilder, type TextInputStyle, type VoiceState, countdown, formatDuration, formatRelative, parseTimestamp, sleep, withTimeout };