baff.js 0.0.0-stage → 0.1.0

package/dist/cjs/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/cjs/structures/channels/ServerChannels.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForumChannel = exports.CategoryChannel = exports.VoiceChannel = exports.ThreadChannel = exports.TextChannel = void 0;
+exports.createChannel = createChannel;
+const ThreadManager_js_1 = require("../../managers/ThreadManager.js");
+const messagePayload_js_1 = require("../../builders/messagePayload.js");
+const Routes_js_1 = require("../../rest/Routes.js");
+const BaffError_js_1 = require("../../errors/BaffError.js");
+const BaseChannel_js_1 = require("./BaseChannel.js");
+const DMChannel_js_1 = require("./DMChannel.js");
+const TextBasedChannel_js_1 = require("./TextBasedChannel.js");
+class TextChannel extends TextBasedChannel_js_1.TextBasedChannel {
+    contentMode = 'default';
+    threads = new ThreadManager_js_1.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';
+    }
+}
+exports.TextChannel = TextChannel;
+class ThreadChannel extends TextBasedChannel_js_1.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 });
+    }
+}
+exports.ThreadChannel = ThreadChannel;
+class VoiceChannel extends BaseChannel_js_1.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_js_1.Routes.channelVoiceStatus(this.id), { body: { status } });
+        this.voiceStatus = status;
+    }
+}
+exports.VoiceChannel = VoiceChannel;
+class CategoryChannel extends BaseChannel_js_1.BaseChannel {
+    get children() {
+        return this.client.channels.cache.filter((c) => c.parentId === this.id && c.inServer());
+    }
+}
+exports.CategoryChannel = CategoryChannel;
+class ForumChannel extends BaseChannel_js_1.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 } = (0, messagePayload_js_1.resolveMessage)(options.message);
+        const payload = { name: options.name, appliedTags: options.appliedTags, autoArchiveMinutes: options.autoArchiveMinutes, message: body };
+        const data = await this.client.rest.post(Routes_js_1.Routes.channelThreads(this.id), { body: payload, files });
+        const post = createChannel(this.client, data);
+        if (!(post instanceof ThreadChannel))
+            throw new BaffError_js_1.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_js_1.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;
+        });
+    }
+}
+exports.ForumChannel = ForumChannel;
+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_js_1.DMChannel(client, data);
+        default:
+            return new TextChannel(client, data);
+    }
+}

package/dist/cjs/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/cjs/structures/channels/TextBasedChannel.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextBasedChannel = void 0;
+const InteractionCollector_js_1 = require("../../collectors/InteractionCollector.js");
+const MessageCollector_js_1 = require("../../collectors/MessageCollector.js");
+const Collector_js_1 = require("../../collectors/Collector.js");
+const MessageManager_js_1 = require("../../managers/MessageManager.js");
+const Routes_js_1 = require("../../rest/Routes.js");
+const Webhook_js_1 = require("../Webhook.js");
+const BaseChannel_js_1 = require("./BaseChannel.js");
+class TextBasedChannel extends BaseChannel_js_1.BaseChannel {
+    messages = new MessageManager_js_1.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_js_1.Routes.channelTyping(this.id));
+    }
+    createMessageCollector(options = {}) {
+        return new MessageCollector_js_1.MessageCollector(this, options);
+    }
+    awaitMessages(options = {}) {
+        return (0, Collector_js_1.awaitCollector)(this.createMessageCollector(options), options.errors);
+    }
+    createMessageComponentCollector(options = {}) {
+        return new InteractionCollector_js_1.InteractionCollector(this.client, { ...options, channelId: this.id });
+    }
+    async awaitMessageComponent(options = {}) {
+        const collected = await (0, Collector_js_1.awaitCollector)(this.createMessageComponentCollector({ ...options, max: 1 }), ['time']);
+        return collected.first();
+    }
+    async createWebhook(name) {
+        return new Webhook_js_1.Webhook(this.client, await this.client.rest.post(Routes_js_1.Routes.channelWebhooks(this.id), { body: { name } }), this.id);
+    }
+    async fetchWebhooks() {
+        const list = await this.client.rest.get(Routes_js_1.Routes.channelWebhooks(this.id));
+        return list.map((data) => new Webhook_js_1.Webhook(this.client, data, this.id));
+    }
+}
+exports.TextBasedChannel = TextBasedChannel;

package/dist/cjs/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 {};

package/dist/cjs/structures/interactions/BaseInteraction.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseInteraction = void 0;
+const messagePayload_js_1 = require("../../builders/messagePayload.js");
+const BaffError_js_1 = require("../../errors/BaffError.js");
+const Routes_js_1 = require("../../rest/Routes.js");
+const Permissions_js_1 = require("../../util/Permissions.js");
+const Base_js_1 = require("../Base.js");
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+class BaseInteraction extends Base_js_1.Identified {
+    raw;
+    id;
+    token;
+    applicationId;
+    channelId;
+    serverId;
+    user;
+    roleIds;
+    memberPermissions;
+    appPermissions;
+    replied = false;
+    deferred = false;
+    ephemeral = false;
+    answeredWith = null;
+    replyMessage = null;
+    sink = null;
+    viaResponse = false;
+    constructor(client, raw) {
+        super(client);
+        this.raw = raw;
+        this.id = raw.id;
+        this.token = raw.token;
+        this.applicationId = raw.applicationId;
+        this.channelId = raw.channelId;
+        this.serverId = raw.serverId;
+        this.user = client.users._add(raw.user);
+        this.roleIds = raw.user.roles ?? [];
+        this.memberPermissions = raw.user.permissions !== undefined ? Permissions_js_1.PermissionsBitField.fromBits(raw.user.permissions) : null;
+        this.appPermissions = raw.appPermissions !== undefined ? Permissions_js_1.PermissionsBitField.fromBits(raw.appPermissions) : null;
+    }
+    get fullCommandName() {
+        return this.commandName;
+    }
+    get channel() {
+        return this.client.channels._textChannel(this.channelId, this.serverId);
+    }
+    get server() {
+        return this.serverId ? (this.client.servers.cache.get(this.serverId) ?? null) : null;
+    }
+    get member() {
+        return this.server?.members.cache.get(this.user.id) ?? null;
+    }
+    get message() {
+        return null;
+    }
+    get responded() {
+        return this.replied || this.deferred;
+    }
+    _setSink(sink) {
+        this.sink = sink;
+        if (sink)
+            this.viaResponse = true;
+    }
+    isChatInputCommand() {
+        return this.raw.type === 'command';
+    }
+    isMessageComponent() {
+        return this.raw.type === 'component';
+    }
+    isButton() {
+        return this.isMessageComponent() && this.raw.data.componentType === 2;
+    }
+    isAnySelectMenu() {
+        return this.isMessageComponent() && [3, 5, 6, 7, 8].includes(this.raw.data.componentType ?? 0);
+    }
+    isStringSelectMenu() {
+        return this.isMessageComponent() && this.raw.data.componentType === 3;
+    }
+    isUserSelectMenu() {
+        return this.isMessageComponent() && this.raw.data.componentType === 5;
+    }
+    isRoleSelectMenu() {
+        return this.isMessageComponent() && this.raw.data.componentType === 6;
+    }
+    isMentionableSelectMenu() {
+        return this.isMessageComponent() && this.raw.data.componentType === 7;
+    }
+    isChannelSelectMenu() {
+        return this.isMessageComponent() && this.raw.data.componentType === 8;
+    }
+    isModalSubmit() {
+        return this.raw.type === 'modal_submit';
+    }
+    isRepliable() {
+        return true;
+    }
+    async reply(options) {
+        this.assertFresh();
+        const { body, files } = (0, messagePayload_js_1.resolveMessage)(options, { allowEphemeral: true });
+        if (files.length)
+            throw new BaffError_js_1.BaffError('INVALID_MESSAGE', 'Interaction answers cannot carry files. Send the files with channel.send or after a defer.');
+        await this.callback({ type: 'message', ...body });
+        this.mark('message', typeof options === 'object' && options.ephemeral === true);
+    }
+    async deferReply(options = {}) {
+        this.assertFresh();
+        await this.callback({ type: 'defer' });
+        this.mark('defer', options.ephemeral === true);
+    }
+    async update(options) {
+        this.assertFresh();
+        this.assertFromMessage();
+        const { body } = (0, messagePayload_js_1.resolveMessage)(options);
+        await this.callback({ type: 'update', ...body });
+        this.mark('update', false);
+    }
+    async deferUpdate() {
+        this.assertFresh();
+        this.assertFromMessage();
+        await this.callback({ type: 'deferUpdate' });
+        this.mark('deferUpdate', false);
+    }
+    async showModal(modal) {
+        this.assertFresh();
+        if (this.isModalSubmit())
+            throw new BaffError_js_1.BaffError('INVALID_INTERACTION', 'A modal submit cannot be answered with another modal.');
+        await this.callback({ type: 'modal', ...('toJSON' in modal ? modal.toJSON() : modal) });
+        this.mark('modal', false);
+    }
+    async editReply(options) {
+        if (!this.responded)
+            throw new BaffError_js_1.BaffError('INTERACTION_NOT_REPLIED', 'Reply to or defer the interaction before editing its reply.');
+        if (this.answeredWith === 'update' || this.answeredWith === 'deferUpdate') {
+            const { body } = (0, messagePayload_js_1.resolveMessage)(options);
+            await this.afterAnswer(() => this.client.rest.patch(Routes_js_1.Routes.interactionOriginal(this.id, this.token), { body, auth: false }));
+            return;
+        }
+        if (this.answeredWith === 'defer' && this.deferred) {
+            const { body, files } = (0, messagePayload_js_1.resolveMessage)(options, { allowEphemeral: true });
+            await this.afterAnswer(() => this.client.rest.post(Routes_js_1.Routes.interactionFollowup(this.id, this.token), { body: { ...body, ephemeral: this.ephemeral }, files, auth: false }));
+            this.deferred = false;
+            this.replied = true;
+            return;
+        }
+        if (this.ephemeral)
+            throw new BaffError_js_1.BaffError('CANNOT_EDIT_REPLY', 'baff.gg cannot edit an ephemeral reply after it was sent. Send a new follow-up or answer with update on a component.');
+        return (await this.fetchReply()).edit(options);
+    }
+    async followUp(options) {
+        if (!this.responded)
+            throw new BaffError_js_1.BaffError('INTERACTION_NOT_REPLIED', 'Reply to or defer the interaction before sending a follow-up.');
+        const { body, files } = (0, messagePayload_js_1.resolveMessage)(options, { allowEphemeral: true });
+        await this.afterAnswer(() => this.client.rest.post(Routes_js_1.Routes.interactionFollowup(this.id, this.token), { body, files, auth: false }));
+        if (this.deferred) {
+            this.deferred = false;
+            this.replied = true;
+        }
+    }
+    async deleteReply() {
+        if (this.ephemeral)
+            throw new BaffError_js_1.BaffError('CANNOT_DELETE_REPLY', 'baff.gg cannot delete an ephemeral reply.');
+        await (await this.fetchReply()).delete();
+        this.replyMessage = null;
+    }
+    async fetchReply() {
+        if (this.replyMessage)
+            return this.replyMessage;
+        if (!this.replied)
+            throw new BaffError_js_1.BaffError('INTERACTION_NOT_REPLIED', 'There is no reply yet.');
+        if (this.ephemeral)
+            throw new BaffError_js_1.BaffError('CANNOT_FETCH_REPLY', 'Ephemeral replies are not stored, so they cannot be fetched.');
+        const self = await this.client.fetchSelf();
+        for (let attempt = 0; attempt < (this.viaResponse ? 20 : 3); attempt++) {
+            const list = await this.client.rest.get(Routes_js_1.Routes.channelMessages(this.channelId), { query: { after: this.id, limit: 25 } });
+            const found = list.find((m) => m.author.id === self.id && m.interaction?.name === this.fullCommandName && m.interaction.user.id === this.user.id);
+            if (found)
+                return (this.replyMessage = this.channel.messages._add({ serverId: this.serverId, ...found }));
+            await sleep(this.viaResponse ? 100 : 150);
+        }
+        throw new BaffError_js_1.BaffError('REPLY_NOT_FOUND', 'Could not find the reply message in this channel.');
+    }
+    async afterAnswer(request) {
+        for (let attempt = 0;; attempt++) {
+            try {
+                return await request();
+            }
+            catch (error) {
+                const early = error instanceof BaffError_js_1.BaffAPIError && error.code === 'not_answered';
+                if (!early || !this.viaResponse || attempt >= 20)
+                    throw error;
+                await sleep(100);
+            }
+        }
+    }
+    async callback(body) {
+        if (this.sink) {
+            const sink = this.sink;
+            this.sink = null;
+            sink(body);
+            return;
+        }
+        await this.client.rest.post(Routes_js_1.Routes.interactionCallback(this.id, this.token), { body, auth: false });
+    }
+    mark(kind, ephemeral) {
+        this.answeredWith = kind;
+        this.ephemeral = ephemeral;
+        if (kind === 'defer')
+            this.deferred = true;
+        else
+            this.replied = true;
+    }
+    assertFresh() {
+        if (this.responded)
+            throw new BaffError_js_1.BaffError('INTERACTION_ALREADY_REPLIED', 'This interaction was already answered. Use followUp or editReply.');
+    }
+    assertFromMessage() {
+        if (!this.raw.message)
+            throw new BaffError_js_1.BaffError('INVALID_INTERACTION', 'Only interactions from a component can update a message.');
+    }
+}
+exports.BaseInteraction = BaseInteraction;

package/dist/cjs/structures/interactions/CommandInteraction.d.ts

@@ -0,0 +1,44 @@
+import type { Client } from '../../client/Client.js';
+import type { APIInteraction, APIInteractionOption } from '../../types.js';
+import type { Role } from '../Role.js';
+import type { User } from '../User.js';
+import type { Channel } from '../channels/ServerChannels.js';
+import { BaseInteraction } from './BaseInteraction.js';
+export declare class CommandInteractionOptions {
+    private readonly client;
+    private readonly serverId;
+    readonly data: APIInteractionOption[];
+    readonly subcommandGroup: string | null;
+    readonly subcommand: string | null;
+    private readonly values;
+    constructor(client: Client, serverId: string | null, options?: APIInteractionOption[]);
+    get(name: string, required?: boolean): APIInteractionOption | null;
+    getSubcommand(required?: boolean): string | null;
+    getSubcommandGroup(required?: boolean): string | null;
+    getString(name: string, required: true): string;
+    getString(name: string, required?: boolean): string | null;
+    getInteger(name: string, required: true): number;
+    getInteger(name: string, required?: boolean): number | null;
+    getNumber(name: string, required: true): number;
+    getNumber(name: string, required?: boolean): number | null;
+    getBoolean(name: string, required: true): boolean;
+    getBoolean(name: string, required?: boolean): boolean | null;
+    getUserId(name: string, required: true): string;
+    getUserId(name: string, required?: boolean): string | null;
+    getRoleId(name: string, required: true): string;
+    getRoleId(name: string, required?: boolean): string | null;
+    getChannelId(name: string, required: true): string;
+    getChannelId(name: string, required?: boolean): string | null;
+    getUser(name: string): User | null;
+    fetchUser(name: string): Promise<User | null>;
+    getRole(name: string): Role | null;
+    getChannel(name: string): Channel | null;
+    private typed;
+}
+export declare class ChatInputCommandInteraction extends BaseInteraction {
+    readonly commandId: string;
+    readonly commandName: string;
+    readonly options: CommandInteractionOptions;
+    constructor(client: Client, raw: APIInteraction);
+    get fullCommandName(): string;
+}