baff.js 0.0.0-stage → 0.1.0

package/dist/esm/structures/User.js

@@ -0,0 +1,82 @@
+import { Routes } from '../rest/Routes.js';
+import { userMention } from '../util/formatters.js';
+import { Identified } from './Base.js';
+export class User extends Identified {
+    id;
+    username;
+    displayName;
+    avatarUrl = null;
+    bannerUrl = null;
+    tag = null;
+    clanTag = null;
+    status = null;
+    customStatus = null;
+    deleted = false;
+    constructor(client, data) {
+        super(client);
+        this.id = data.id;
+        this.username = data.username;
+        this.displayName = data.displayName || data.username;
+        this._patch(data);
+    }
+    _patch(data) {
+        if (data.username !== undefined)
+            this.username = data.username;
+        if (data.displayName !== undefined)
+            this.displayName = data.displayName || this.username;
+        if (data.avatarUrl !== undefined)
+            this.avatarUrl = data.avatarUrl;
+        if (data.bannerUrl !== undefined)
+            this.bannerUrl = data.bannerUrl;
+        if (data.tag !== undefined)
+            this.tag = data.tag;
+        if (data.clanTag !== undefined)
+            this.clanTag = data.clanTag;
+        if (data.status !== undefined)
+            this.status = data.status;
+        if (data.customStatus !== undefined)
+            this.customStatus = data.customStatus;
+        if (data.deleted !== undefined)
+            this.deleted = data.deleted;
+        return this;
+    }
+    get bot() {
+        return this.tag === 'bot' || this.tag === 'verified_bot';
+    }
+    get system() {
+        return this.tag === 'system';
+    }
+    async createDM() {
+        const data = await this.client.rest.post(Routes.dms(), { body: { recipientId: this.id } });
+        return this.client.channels._addDM(data);
+    }
+    async send(options) {
+        return (await this.createDM()).send(options);
+    }
+    async fetchProfile(serverId) {
+        const profile = await this.client.rest.get(Routes.userProfile(this.id), { query: { serverId } });
+        this._patch(profile.user);
+        return profile;
+    }
+    toString() {
+        return userMention(this.id);
+    }
+}
+export class ClientUser extends User {
+    get bot() {
+        return true;
+    }
+    async setPresence(presence) {
+        await this.client.rest.patch(Routes.presence(), { body: presence });
+        if (presence.status)
+            this.status = presence.status;
+        if (presence.customStatus !== undefined)
+            this.customStatus = presence.customStatus;
+    }
+    setStatus(status) {
+        return this.setPresence({ status });
+    }
+    setCustomStatus(customStatus) {
+        return this.setPresence({ customStatus });
+    }
+}

package/dist/esm/structures/Webhook.d.ts

@@ -0,0 +1,30 @@
+import type { Client } from '../client/Client.js';
+import { type MessageOptions } from '../builders/messagePayload.js';
+import { type RESTOptions } from '../rest/REST.js';
+import type { APIWebhook } from '../types.js';
+import { Identified } from './Base.js';
+export type WebhookMessageOptions = Pick<MessageOptions, 'content' | 'embeds' | 'components' | 'flags'>;
+export declare class Webhook extends Identified {
+    readonly channelId: string;
+    readonly id: string;
+    readonly userId: string;
+    readonly token: string;
+    readonly path: string;
+    name: string;
+    constructor(client: Client, data: APIWebhook, channelId: string);
+    get url(): string;
+    send(options: string | WebhookMessageOptions): Promise<void>;
+    edit(name: string): Promise<Webhook>;
+    delete(): Promise<void>;
+}
+export declare class WebhookClient {
+    readonly id: string;
+    readonly token: string;
+    private readonly rest;
+    constructor(target: string | {
+        id: string;
+        token: string;
+        api?: string;
+    }, options?: Omit<RESTOptions, 'token' | 'api'>);
+    send(options: string | WebhookMessageOptions): Promise<void>;
+}

package/dist/esm/structures/Webhook.js

@@ -0,0 +1,63 @@
+import { resolveMessage } from '../builders/messagePayload.js';
+import { BaffError } from '../errors/BaffError.js';
+import { REST } from '../rest/REST.js';
+import { Routes } from '../rest/Routes.js';
+import { Identified } from './Base.js';
+export class Webhook extends Identified {
+    channelId;
+    id;
+    userId;
+    token;
+    path;
+    name;
+    constructor(client, data, channelId) {
+        super(client);
+        this.channelId = channelId;
+        this.id = data.id;
+        this.userId = data.userId;
+        this.name = data.name;
+        this.path = data.path;
+        this.token = data.path.split('/').filter(Boolean).at(-1) ?? '';
+    }
+    get url() {
+        return `${this.client.appUrl}${this.path}`;
+    }
+    async send(options) {
+        await send(this.client.rest, this.id, this.token, options);
+    }
+    async edit(name) {
+        await this.client.rest.patch(Routes.webhook(this.id), { body: { name } });
+        this.name = name;
+        return this;
+    }
+    delete() {
+        return this.client.rest.delete(Routes.webhook(this.id));
+    }
+}
+async function send(rest, id, token, options) {
+    const { body } = resolveMessage(options);
+    await rest.post(Routes.webhookExecute(id, token), { body, auth: false });
+}
+export class WebhookClient {
+    id;
+    token;
+    rest;
+    constructor(target, options = {}) {
+        let api;
+        if (typeof target === 'string') {
+            const match = /^(https?:\/\/.+?)\/api\/webhooks\/(\d+)\/([^/?#]+)/.exec(target);
+            if (!match)
+                throw new BaffError('INVALID_WEBHOOK_URL', 'Expected a URL like https://baff.gg/api/webhooks/<id>/<token>.');
+            api = `${match[1]}/api`;
+            this.id = match[2];
+            this.token = match[3];
+        }
+        else {
+            ({ id: this.id, token: this.token, api } = target);
+        }
+        this.rest = new REST({ ...options, api });
+    }
+    send(options) {
+        return send(this.rest, this.id, this.token, options);
+    }
+}

package/dist/esm/structures/channels/BaseChannel.d.ts

@@ -0,0 +1,49 @@
+import type { Client } from '../../client/Client.js';
+import type { APIChannel, ChannelKind } from '../../types.js';
+import { Identified } from '../Base.js';
+import type { Server } from '../Server.js';
+import type { CategoryChannel, ForumChannel, ServerChannel, ThreadChannel, VoiceChannel } from './ServerChannels.js';
+import type { DMChannel } from './DMChannel.js';
+import type { TextBasedChannel } from './TextBasedChannel.js';
+export interface ChannelEditData {
+    name?: string;
+    topic?: string | null;
+    slowmodeSecs?: number;
+    contentMode?: 'default' | 'spoiler' | 'age_restricted';
+    parentId?: string | null;
+    kind?: 'text' | 'announcement';
+    autoArchiveMinutes?: number;
+    archived?: boolean;
+    locked?: boolean;
+    availableTags?: {
+        id?: string;
+        name: string;
+        emoji?: string | null;
+    }[];
+    requireTag?: boolean;
+    defaultSortOrder?: 'activity' | 'created';
+}
+export declare class BaseChannel extends Identified {
+    readonly id: string;
+    kind: ChannelKind;
+    name: string | null;
+    serverId: string | null;
+    parentId: string | null;
+    position: number;
+    constructor(client: Client, data: APIChannel);
+    _patch(data: Partial<APIChannel>): this;
+    get server(): Server | null;
+    get parent(): CategoryChannel | null;
+    get url(): string;
+    isTextBased(): this is TextBasedChannel;
+    isVoiceBased(): this is VoiceChannel;
+    isThread(): this is ThreadChannel;
+    isDM(): this is DMChannel;
+    isForum(): this is ForumChannel;
+    isCategory(): this is CategoryChannel;
+    inServer(): this is ServerChannel;
+    edit(data: ChannelEditData): Promise<this>;
+    setName(name: string): Promise<this>;
+    delete(): Promise<void>;
+    toString(): string;
+}

package/dist/esm/structures/channels/BaseChannel.js

@@ -0,0 +1,77 @@
+import { Routes } from '../../rest/Routes.js';
+import { channelMention } from '../../util/formatters.js';
+import { Identified } from '../Base.js';
+export class BaseChannel extends Identified {
+    id;
+    kind;
+    name = null;
+    serverId = null;
+    parentId = null;
+    position = 0;
+    constructor(client, data) {
+        super(client);
+        this.id = data.id;
+        this.kind = (data.kind ?? data.type ?? 'text');
+    }
+    _patch(data) {
+        if (data.kind ?? data.type)
+            this.kind = (data.kind ?? data.type);
+        if (data.name !== undefined)
+            this.name = data.name;
+        if (data.serverId !== undefined)
+            this.serverId = data.serverId;
+        if (data.parentId !== undefined)
+            this.parentId = data.parentId;
+        if (data.position !== undefined)
+            this.position = data.position;
+        return this;
+    }
+    get server() {
+        return this.serverId ? (this.client.servers.cache.get(this.serverId) ?? null) : null;
+    }
+    get parent() {
+        const parent = this.parentId ? this.client.channels.cache.get(this.parentId) : undefined;
+        return parent?.isCategory() ? parent : null;
+    }
+    get url() {
+        const base = this.client.appUrl;
+        return this.serverId ? `${base}/channels/${this.serverId}/${this.id}` : `${base}/channels/@me/${this.id}`;
+    }
+    isTextBased() {
+        return ['text', 'announcement', 'stage', 'thread', 'dm', 'group_dm'].includes(this.kind);
+    }
+    isVoiceBased() {
+        return this.kind === 'voice';
+    }
+    isThread() {
+        return this.kind === 'thread';
+    }
+    isDM() {
+        return this.kind === 'dm' || this.kind === 'group_dm';
+    }
+    isForum() {
+        return this.kind === 'forum';
+    }
+    isCategory() {
+        return this.kind === 'category';
+    }
+    inServer() {
+        return this.serverId !== null;
+    }
+    async edit(data) {
+        const updated = await this.client.rest.patch(Routes.channel(this.id), { body: data });
+        if (updated && typeof updated === 'object' && updated.id === this.id)
+            this._patch(updated);
+        return this;
+    }
+    setName(name) {
+        return this.edit({ name });
+    }
+    async delete() {
+        await this.client.rest.delete(Routes.channel(this.id));
+        this.client.channels._remove(this.id);
+    }
+    toString() {
+        return channelMention(this.id);
+    }
+}

package/dist/esm/structures/channels/DMChannel.d.ts

@@ -0,0 +1,9 @@
+import type { APIChannel } from '../../types.js';
+import type { User } from '../User.js';
+import { TextBasedChannel } from './TextBasedChannel.js';
+export declare class DMChannel extends TextBasedChannel {
+    recipients: User[];
+    _patch(data: Partial<APIChannel>): this;
+    get recipient(): User | null;
+    get url(): string;
+}

package/dist/esm/structures/channels/DMChannel.js

@@ -0,0 +1,17 @@
+import { TextBasedChannel } from './TextBasedChannel.js';
+export class DMChannel extends TextBasedChannel {
+    recipients = [];
+    _patch(data) {
+        super._patch(data);
+        const people = data.recipients ?? (data.recipient ? [data.recipient] : undefined);
+        if (people)
+            this.recipients = people.map((p) => this.client.users._add(p));
+        return this;
+    }
+    get recipient() {
+        return this.recipients[0] ?? null;
+    }
+    get url() {
+        return `${this.client.appUrl}/channels/@me/${this.id}`;
+    }
+}

package/dist/esm/structures/channels/ServerChannels.d.ts

@@ -0,0 +1,57 @@
+import type { Client } from '../../client/Client.js';
+import { ThreadManager } from '../../managers/ThreadManager.js';
+import type { MessageOptions } from '../../builders/messagePayload.js';
+import type { APIChannel, APIVoiceJoin } from '../../types.js';
+import { Collection } from '../../util/Collection.js';
+import { BaseChannel } from './BaseChannel.js';
+import { DMChannel } from './DMChannel.js';
+import { TextBasedChannel } from './TextBasedChannel.js';
+export declare class TextChannel extends TextBasedChannel {
+    contentMode: 'default' | 'spoiler' | 'age_restricted';
+    readonly threads: ThreadManager;
+    _patch(data: Partial<APIChannel>): this;
+    get isAnnouncement(): boolean;
+    get isStage(): boolean;
+}
+export declare class ThreadChannel extends TextBasedChannel {
+    ownerId: string | null;
+    starterId: string | null;
+    archived: boolean;
+    locked: boolean;
+    autoArchiveMinutes: number | null;
+    messageCount: number;
+    _patch(data: Partial<APIChannel>): this;
+    setArchived(archived?: boolean): Promise<this>;
+    setLocked(locked?: boolean): Promise<this>;
+}
+export declare class VoiceChannel extends BaseChannel {
+    voiceStatus: string | null;
+    _patch(data: Partial<APIChannel>): this;
+    join(): Promise<APIVoiceJoin>;
+    setVoiceStatus(status: string | null): Promise<void>;
+}
+export declare class CategoryChannel extends BaseChannel {
+    get children(): Collection<string, ServerChannel>;
+}
+export declare class ForumChannel extends BaseChannel {
+    topic: string | null;
+    availableTags: NonNullable<APIChannel['availableTags']>;
+    requireTag: boolean;
+    _patch(data: Partial<APIChannel>): this;
+    createPost(options: {
+        name: string;
+        message: string | MessageOptions;
+        appliedTags?: string[];
+        autoArchiveMinutes?: number;
+    }): Promise<ThreadChannel>;
+    fetchPosts(options?: {
+        sort?: 'activity' | 'created';
+        q?: string;
+        tags?: string[];
+        offset?: number;
+        limit?: number;
+    }): Promise<ThreadChannel[]>;
+}
+export type ServerChannel = TextChannel | ThreadChannel | VoiceChannel | CategoryChannel | ForumChannel;
+export type Channel = ServerChannel | DMChannel;
+export declare function createChannel(client: Client, data: APIChannel): Channel;

package/dist/esm/structures/channels/ServerChannels.js

@@ -0,0 +1,129 @@
+import { ThreadManager } from '../../managers/ThreadManager.js';
+import { resolveMessage } from '../../builders/messagePayload.js';
+import { Routes } from '../../rest/Routes.js';
+import { BaffError } from '../../errors/BaffError.js';
+import { BaseChannel } from './BaseChannel.js';
+import { DMChannel } from './DMChannel.js';
+import { TextBasedChannel } from './TextBasedChannel.js';
+export class TextChannel extends TextBasedChannel {
+    contentMode = 'default';
+    threads = new ThreadManager(this);
+    _patch(data) {
+        super._patch(data);
+        if (data.contentMode !== undefined)
+            this.contentMode = data.contentMode;
+        return this;
+    }
+    get isAnnouncement() {
+        return this.kind === 'announcement';
+    }
+    get isStage() {
+        return this.kind === 'stage';
+    }
+}
+export class ThreadChannel extends TextBasedChannel {
+    ownerId = null;
+    starterId = null;
+    archived = false;
+    locked = false;
+    autoArchiveMinutes = null;
+    messageCount = 0;
+    _patch(data) {
+        super._patch(data);
+        if (data.threadOwnerId !== undefined)
+            this.ownerId = data.threadOwnerId;
+        if (data.threadStarterId !== undefined)
+            this.starterId = data.threadStarterId;
+        if (data.archived !== undefined)
+            this.archived = data.archived;
+        if (data.threadLocked !== undefined)
+            this.locked = data.threadLocked;
+        if (data.autoArchiveMinutes !== undefined)
+            this.autoArchiveMinutes = data.autoArchiveMinutes;
+        if (data.messageCount !== undefined)
+            this.messageCount = data.messageCount;
+        return this;
+    }
+    setArchived(archived = true) {
+        return this.edit({ archived });
+    }
+    setLocked(locked = true) {
+        return this.edit({ locked });
+    }
+}
+export class VoiceChannel extends BaseChannel {
+    voiceStatus = null;
+    _patch(data) {
+        super._patch(data);
+        if (data.voiceStatus !== undefined)
+            this.voiceStatus = data.voiceStatus;
+        return this;
+    }
+    join() {
+        return this.client.voice.join(this.id);
+    }
+    async setVoiceStatus(status) {
+        await this.client.rest.put(Routes.channelVoiceStatus(this.id), { body: { status } });
+        this.voiceStatus = status;
+    }
+}
+export class CategoryChannel extends BaseChannel {
+    get children() {
+        return this.client.channels.cache.filter((c) => c.parentId === this.id && c.inServer());
+    }
+}
+export class ForumChannel extends BaseChannel {
+    topic = null;
+    availableTags = [];
+    requireTag = false;
+    _patch(data) {
+        super._patch(data);
+        if (data.topic !== undefined)
+            this.topic = data.topic;
+        if (data.availableTags !== undefined)
+            this.availableTags = data.availableTags;
+        if (data.requireTag !== undefined)
+            this.requireTag = data.requireTag;
+        return this;
+    }
+    async createPost(options) {
+        const { body, files } = resolveMessage(options.message);
+        const payload = { name: options.name, appliedTags: options.appliedTags, autoArchiveMinutes: options.autoArchiveMinutes, message: body };
+        const data = await this.client.rest.post(Routes.channelThreads(this.id), { body: payload, files });
+        const post = createChannel(this.client, data);
+        if (!(post instanceof ThreadChannel))
+            throw new BaffError('UNEXPECTED_RESPONSE', 'The server did not answer with a post.');
+        this.client.channels._set(post);
+        return post;
+    }
+    async fetchPosts(options = {}) {
+        const res = await this.client.rest.get(Routes.channelPosts(this.id), { query: { ...options } });
+        return res.posts.map((p) => {
+            const post = createChannel(this.client, p.channel);
+            this.client.channels._set(post);
+            return post;
+        });
+    }
+}
+export function createChannel(client, data) {
+    const channel = construct(client, data);
+    channel._patch(data);
+    return channel;
+}
+function construct(client, data) {
+    switch (data.kind ?? data.type) {
+        case 'thread':
+            return new ThreadChannel(client, data);
+        case 'voice':
+            return new VoiceChannel(client, data);
+        case 'category':
+            return new CategoryChannel(client, data);
+        case 'forum':
+            return new ForumChannel(client, data);
+        case 'dm':
+        case 'group_dm':
+            return new DMChannel(client, data);
+        default:
+            return new TextChannel(client, data);
+    }
+}

package/dist/esm/structures/channels/TextBasedChannel.d.ts

@@ -0,0 +1,25 @@
+import type { MessageOptions } from '../../builders/messagePayload.js';
+import { InteractionCollector, type InteractionCollectorOptions } from '../../collectors/InteractionCollector.js';
+import { MessageCollector, type AwaitMessagesOptions, type MessageCollectorOptions } from '../../collectors/MessageCollector.js';
+import { MessageManager } from '../../managers/MessageManager.js';
+import type { APIChannel } from '../../types.js';
+import type { Collection } from '../../util/Collection.js';
+import type { MessageComponentInteraction } from '../interactions/ComponentInteraction.js';
+import type { Message } from '../Message.js';
+import { Webhook } from '../Webhook.js';
+import { BaseChannel } from './BaseChannel.js';
+export declare class TextBasedChannel extends BaseChannel {
+    readonly messages: MessageManager;
+    lastMessageId: string | null;
+    topic: string | null;
+    slowmodeSecs: number;
+    _patch(data: Partial<APIChannel>): this;
+    send(options: string | MessageOptions): Promise<Message>;
+    sendTyping(): Promise<void>;
+    createMessageCollector(options?: MessageCollectorOptions): MessageCollector;
+    awaitMessages(options?: AwaitMessagesOptions): Promise<Collection<string, Message>>;
+    createMessageComponentCollector(options?: InteractionCollectorOptions): InteractionCollector;
+    awaitMessageComponent(options?: InteractionCollectorOptions): Promise<MessageComponentInteraction>;
+    createWebhook(name: string): Promise<Webhook>;
+    fetchWebhooks(): Promise<Webhook[]>;
+}

package/dist/esm/structures/channels/TextBasedChannel.js

@@ -0,0 +1,49 @@
+import { InteractionCollector } from '../../collectors/InteractionCollector.js';
+import { MessageCollector } from '../../collectors/MessageCollector.js';
+import { awaitCollector } from '../../collectors/Collector.js';
+import { MessageManager } from '../../managers/MessageManager.js';
+import { Routes } from '../../rest/Routes.js';
+import { Webhook } from '../Webhook.js';
+import { BaseChannel } from './BaseChannel.js';
+export class TextBasedChannel extends BaseChannel {
+    messages = new MessageManager(this);
+    lastMessageId = null;
+    topic = null;
+    slowmodeSecs = 0;
+    _patch(data) {
+        super._patch(data);
+        if (data.lastMessageId !== undefined)
+            this.lastMessageId = data.lastMessageId;
+        if (data.topic !== undefined)
+            this.topic = data.topic;
+        if (data.slowmodeSecs !== undefined)
+            this.slowmodeSecs = data.slowmodeSecs;
+        return this;
+    }
+    send(options) {
+        return this.messages.send(options);
+    }
+    async sendTyping() {
+        await this.client.rest.post(Routes.channelTyping(this.id));
+    }
+    createMessageCollector(options = {}) {
+        return new MessageCollector(this, options);
+    }
+    awaitMessages(options = {}) {
+        return awaitCollector(this.createMessageCollector(options), options.errors);
+    }
+    createMessageComponentCollector(options = {}) {
+        return new InteractionCollector(this.client, { ...options, channelId: this.id });
+    }
+    async awaitMessageComponent(options = {}) {
+        const collected = await awaitCollector(this.createMessageComponentCollector({ ...options, max: 1 }), ['time']);
+        return collected.first();
+    }
+    async createWebhook(name) {
+        return new Webhook(this.client, await this.client.rest.post(Routes.channelWebhooks(this.id), { body: { name } }), this.id);
+    }
+    async fetchWebhooks() {
+        const list = await this.client.rest.get(Routes.channelWebhooks(this.id));
+        return list.map((data) => new Webhook(this.client, data, this.id));
+    }
+}

package/dist/esm/structures/interactions/BaseInteraction.d.ts

@@ -0,0 +1,74 @@
+import type { Client } from '../../client/Client.js';
+import { type MessageOptions } from '../../builders/messagePayload.js';
+import type { ModalBuilder } from '../../builders/components/ModalBuilder.js';
+import type { APIInteraction } from '../../types.js';
+import { PermissionsBitField } from '../../util/Permissions.js';
+import { Identified } from '../Base.js';
+import type { TextBasedChannel } from '../channels/TextBasedChannel.js';
+import type { Message } from '../Message.js';
+import type { Server } from '../Server.js';
+import type { ServerMember } from '../ServerMember.js';
+import type { User } from '../User.js';
+import type { ButtonInteraction, ChannelSelectMenuInteraction, MentionableSelectMenuInteraction, MessageComponentInteraction, RoleSelectMenuInteraction, SelectMenuInteraction, StringSelectMenuInteraction, UserSelectMenuInteraction } from './ComponentInteraction.js';
+import type { ChatInputCommandInteraction } from './CommandInteraction.js';
+import type { ModalSubmitInteraction } from './ModalSubmitInteraction.js';
+export interface InteractionReplyOptions extends MessageOptions {
+    ephemeral?: boolean;
+}
+type AnswerKind = 'message' | 'defer' | 'update' | 'deferUpdate' | 'modal';
+export declare abstract class BaseInteraction extends Identified {
+    protected readonly raw: APIInteraction;
+    readonly id: string;
+    readonly token: string;
+    readonly applicationId: string;
+    readonly channelId: string;
+    readonly serverId: string | null;
+    readonly user: User;
+    readonly roleIds: string[];
+    readonly memberPermissions: PermissionsBitField | null;
+    readonly appPermissions: PermissionsBitField | null;
+    replied: boolean;
+    deferred: boolean;
+    ephemeral: boolean;
+    protected answeredWith: AnswerKind | null;
+    protected replyMessage: Message | null;
+    private sink;
+    private viaResponse;
+    constructor(client: Client, raw: APIInteraction);
+    abstract readonly commandName: string;
+    get fullCommandName(): string;
+    get channel(): TextBasedChannel;
+    get server(): Server | null;
+    get member(): ServerMember | null;
+    get message(): Message | null;
+    get responded(): boolean;
+    _setSink(sink: ((body: Record<string, unknown>) => void) | null): void;
+    isChatInputCommand(): this is ChatInputCommandInteraction;
+    isMessageComponent(): this is MessageComponentInteraction;
+    isButton(): this is ButtonInteraction;
+    isAnySelectMenu(): this is SelectMenuInteraction;
+    isStringSelectMenu(): this is StringSelectMenuInteraction;
+    isUserSelectMenu(): this is UserSelectMenuInteraction;
+    isRoleSelectMenu(): this is RoleSelectMenuInteraction;
+    isMentionableSelectMenu(): this is MentionableSelectMenuInteraction;
+    isChannelSelectMenu(): this is ChannelSelectMenuInteraction;
+    isModalSubmit(): this is ModalSubmitInteraction;
+    isRepliable(): boolean;
+    reply(options: string | InteractionReplyOptions): Promise<void>;
+    deferReply(options?: {
+        ephemeral?: boolean;
+    }): Promise<void>;
+    update(options: string | MessageOptions): Promise<void>;
+    deferUpdate(): Promise<void>;
+    showModal(modal: ModalBuilder | ReturnType<ModalBuilder['toJSON']>): Promise<void>;
+    editReply(options: string | MessageOptions): Promise<Message | void>;
+    followUp(options: string | InteractionReplyOptions): Promise<void>;
+    deleteReply(): Promise<void>;
+    fetchReply(): Promise<Message>;
+    private afterAnswer;
+    private callback;
+    private mark;
+    private assertFresh;
+    private assertFromMessage;
+}
+export {};