@jubbio/core 1.1.20 → 1.3.2

package/dist/cjs/structures/Interaction.js

@@ -0,0 +1,450 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModalFields = exports.ModalSubmitInteraction = exports.SelectMenuInteraction = exports.ButtonInteraction = exports.AutocompleteInteraction = exports.CommandInteractionOptions = exports.CommandInteraction = exports.Interaction = void 0;
+exports.createInteraction = createInteraction;
+const enums_1 = require("../enums");
+const User_1 = require("./User");
+const GuildMember_1 = require("./GuildMember");
+const EmbedBuilder_1 = require("../builders/EmbedBuilder");
+/**
+ * Base interaction class
+ */
+class Interaction {
+    /** Reference to the client */
+    client;
+    /** Interaction ID */
+    id;
+    /** Application ID */
+    applicationId;
+    /** Interaction type */
+    type;
+    /** Guild ID */
+    guildId;
+    /** Channel ID */
+    channelId;
+    /** Interaction token */
+    token;
+    /** User who triggered the interaction */
+    user;
+    /** Guild member (if in a guild) */
+    member;
+    /** Whether the interaction has been replied to */
+    replied = false;
+    /** Whether the interaction has been deferred */
+    deferred = false;
+    constructor(client, data) {
+        this.client = client;
+        // Handle both string and number IDs
+        this.id = String(data.id);
+        this.applicationId = String(data.application_id);
+        this.type = data.type;
+        this.guildId = data.guild_id ? String(data.guild_id) : undefined;
+        this.channelId = data.channel_id ? String(data.channel_id) : undefined;
+        this.token = data.token;
+        // User can come from member.user or directly from user
+        const userData = data.member?.user || data.user;
+        this.user = userData ? new User_1.User(userData) : new User_1.User({ id: '0', username: 'Unknown' });
+        // Create member if in guild
+        if (data.member && this.guildId) {
+            const guild = client.guilds.get(this.guildId) || { id: this.guildId, ownerId: null };
+            this.member = new GuildMember_1.GuildMember(client, guild, data.member);
+        }
+    }
+    /**
+     * Check if this is a command interaction
+     */
+    isCommand() {
+        return this.type === enums_1.InteractionType.ApplicationCommand;
+    }
+    /**
+     * Check if this is an autocomplete interaction
+     */
+    isAutocomplete() {
+        return this.type === enums_1.InteractionType.ApplicationCommandAutocomplete;
+    }
+    /**
+     * Check if this is a modal submit interaction
+     */
+    isModalSubmit() {
+        return this.type === enums_1.InteractionType.ModalSubmit;
+    }
+    /**
+     * Check if this is a button interaction
+     */
+    isButton() {
+        return this.type === enums_1.InteractionType.MessageComponent && this.componentType === 2;
+    }
+    /**
+     * Check if this is a select menu interaction
+     */
+    isSelectMenu() {
+        return this.type === enums_1.InteractionType.MessageComponent && this.componentType === 3;
+    }
+    /**
+     * Reply to the interaction
+     */
+    async reply(options) {
+        if (this.replied || this.deferred) {
+            throw new Error('Interaction has already been replied to or deferred');
+        }
+        const content = typeof options === 'string' ? options : options.content;
+        const rawEmbeds = typeof options === 'string' ? undefined : options.embeds;
+        const components = typeof options === 'string' ? undefined : options.components;
+        const ephemeral = typeof options === 'string' ? false : options.ephemeral;
+        // Convert EmbedBuilder instances to plain objects
+        const embeds = rawEmbeds?.map(e => e instanceof EmbedBuilder_1.EmbedBuilder ? e.toJSON() : e);
+        await this.client.rest.createInteractionResponse(this.id, this.token, {
+            type: enums_1.InteractionResponseType.ChannelMessageWithSource,
+            data: {
+                content,
+                embeds,
+                components,
+                flags: ephemeral ? enums_1.MessageFlags.Ephemeral : 0
+            }
+        });
+        this.replied = true;
+    }
+    /**
+     * Defer the reply (shows "thinking...")
+     */
+    async deferReply(options) {
+        if (this.replied || this.deferred) {
+            throw new Error('Interaction has already been replied to or deferred');
+        }
+        await this.client.rest.createInteractionResponse(this.id, this.token, {
+            type: enums_1.InteractionResponseType.DeferredChannelMessageWithSource,
+            data: options?.ephemeral ? { flags: enums_1.MessageFlags.Ephemeral } : undefined
+        });
+        this.deferred = true;
+    }
+    /**
+     * Edit the reply
+     */
+    async editReply(options) {
+        const content = typeof options === 'string' ? options : options.content;
+        const rawEmbeds = typeof options === 'string' ? undefined : options.embeds;
+        const components = typeof options === 'string' ? undefined : options.components;
+        const files = typeof options === 'string' ? undefined : options.files;
+        // Convert EmbedBuilder instances to plain objects
+        const embeds = rawEmbeds?.map(e => e instanceof EmbedBuilder_1.EmbedBuilder ? e.toJSON() : e);
+        await this.client.rest.editInteractionResponse(this.token, {
+            content,
+            embeds,
+            components,
+            files
+        }, this.guildId, this.channelId, this.id);
+    }
+    /**
+     * Delete the reply
+     */
+    async deleteReply() {
+        await this.client.rest.deleteInteractionResponse(this.token);
+    }
+    /**
+     * Send a followup message
+     */
+    async followUp(options) {
+        const content = typeof options === 'string' ? options : options.content;
+        const rawEmbeds = typeof options === 'string' ? undefined : options.embeds;
+        const ephemeral = typeof options === 'string' ? false : options.ephemeral;
+        // Convert EmbedBuilder instances to plain objects
+        const embeds = rawEmbeds?.map(e => e instanceof EmbedBuilder_1.EmbedBuilder ? e.toJSON() : e);
+        await this.client.rest.createFollowup(this.token, {
+            content,
+            embeds,
+            flags: ephemeral ? enums_1.MessageFlags.Ephemeral : 0
+        });
+    }
+}
+exports.Interaction = Interaction;
+/**
+ * Command interaction
+ */
+class CommandInteraction extends Interaction {
+    /** Command name */
+    commandName;
+    /** Command options */
+    options;
+    constructor(client, data) {
+        super(client, data);
+        this.commandName = data.data?.name || '';
+        this.options = new CommandInteractionOptions(data.data?.options || []);
+    }
+    /**
+     * Show a modal
+     */
+    async showModal(modal) {
+        const modalData = 'toJSON' in modal && typeof modal.toJSON === 'function' ? modal.toJSON() : modal;
+        await this.client.rest.createInteractionResponse(this.id, this.token, {
+            type: enums_1.InteractionResponseType.Modal,
+            data: modalData
+        });
+    }
+}
+exports.CommandInteraction = CommandInteraction;
+/**
+ * Command interaction options helper
+ */
+class CommandInteractionOptions {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Get a string option
+     */
+    getString(name, required) {
+        const option = this.options.find(o => o.name === name);
+        if (!option && required)
+            throw new Error(`Required option "${name}" not found`);
+        return option?.value || null;
+    }
+    /**
+     * Get an integer option
+     */
+    getInteger(name, required) {
+        const option = this.options.find(o => o.name === name);
+        if (!option && required)
+            throw new Error(`Required option "${name}" not found`);
+        return option?.value || null;
+    }
+    /**
+     * Get a number option
+     */
+    getNumber(name, required) {
+        return this.getInteger(name, required);
+    }
+    /**
+     * Get a boolean option
+     */
+    getBoolean(name, required) {
+        const option = this.options.find(o => o.name === name);
+        if (!option && required)
+            throw new Error(`Required option "${name}" not found`);
+        return option?.value ?? null;
+    }
+    /**
+     * Get a user option
+     */
+    getUser(name, required) {
+        const option = this.options.find(o => o.name === name);
+        if (!option && required)
+            throw new Error(`Required option "${name}" not found`);
+        return option?.value || null;
+    }
+    /**
+     * Get a channel option
+     */
+    getChannel(name, required) {
+        const option = this.options.find(o => o.name === name);
+        if (!option && required)
+            throw new Error(`Required option "${name}" not found`);
+        return option?.value || null;
+    }
+    /**
+     * Get a subcommand name
+     */
+    getSubcommand(required) {
+        const option = this.options.find(o => o.type === 1);
+        if (!option && required)
+            throw new Error('Required subcommand not found');
+        return option?.name || null;
+    }
+    /**
+     * Get the focused option (for autocomplete)
+     */
+    getFocused() {
+        const option = this.options.find(o => o.focused);
+        if (!option)
+            return null;
+        return { name: option.name, value: option.value };
+    }
+}
+exports.CommandInteractionOptions = CommandInteractionOptions;
+/**
+ * Autocomplete interaction
+ */
+class AutocompleteInteraction extends Interaction {
+    /** Command name */
+    commandName;
+    /** Command options */
+    options;
+    constructor(client, data) {
+        super(client, data);
+        this.commandName = data.data?.name || '';
+        this.options = new CommandInteractionOptions(data.data?.options || []);
+    }
+    /**
+     * Respond with autocomplete choices
+     */
+    async respond(choices) {
+        await this.client.rest.createInteractionResponse(this.id, this.token, {
+            type: enums_1.InteractionResponseType.ApplicationCommandAutocompleteResult,
+            data: { choices }
+        });
+    }
+}
+exports.AutocompleteInteraction = AutocompleteInteraction;
+/**
+ * Button interaction
+ */
+class ButtonInteraction extends Interaction {
+    /** Button custom ID */
+    customId;
+    /** Component type (always 2 for buttons) */
+    componentType = 2;
+    /** Message the button is attached to */
+    message;
+    constructor(client, data) {
+        super(client, data);
+        this.customId = data.data?.custom_id || '';
+        this.message = data.message;
+    }
+    /**
+     * Update the message the button is attached to
+     */
+    async update(options) {
+        // Convert EmbedBuilder instances to plain objects
+        const embeds = options.embeds?.map(e => e instanceof EmbedBuilder_1.EmbedBuilder ? e.toJSON() : e);
+        await this.client.rest.createInteractionResponse(this.id, this.token, {
+            type: enums_1.InteractionResponseType.UpdateMessage,
+            data: {
+                content: options.content,
+                embeds,
+                components: options.components
+            }
+        });
+        this.replied = true;
+    }
+    /**
+     * Show a modal in response to this button interaction
+     */
+    async showModal(modal) {
+        const modalData = 'toJSON' in modal && typeof modal.toJSON === 'function' ? modal.toJSON() : modal;
+        await this.client.rest.createInteractionResponse(this.id, this.token, {
+            type: enums_1.InteractionResponseType.Modal,
+            data: modalData
+        });
+    }
+}
+exports.ButtonInteraction = ButtonInteraction;
+/**
+ * Select menu interaction
+ */
+class SelectMenuInteraction extends Interaction {
+    /** Select menu custom ID */
+    customId;
+    /** Component type (always 3 for select menus) */
+    componentType = 3;
+    /** Selected values */
+    values;
+    /** Message the select menu is attached to */
+    message;
+    constructor(client, data) {
+        super(client, data);
+        this.customId = data.data?.custom_id || '';
+        this.values = data.data?.values || [];
+        this.message = data.message;
+    }
+    /**
+     * Update the message the select menu is attached to
+     */
+    async update(options) {
+        // Convert EmbedBuilder instances to plain objects
+        const embeds = options.embeds?.map(e => e instanceof EmbedBuilder_1.EmbedBuilder ? e.toJSON() : e);
+        await this.client.rest.createInteractionResponse(this.id, this.token, {
+            type: enums_1.InteractionResponseType.UpdateMessage,
+            data: {
+                content: options.content,
+                embeds,
+                components: options.components
+            }
+        });
+        this.replied = true;
+    }
+    /**
+     * Show a modal in response to this select menu interaction
+     */
+    async showModal(modal) {
+        const modalData = 'toJSON' in modal && typeof modal.toJSON === 'function' ? modal.toJSON() : modal;
+        await this.client.rest.createInteractionResponse(this.id, this.token, {
+            type: enums_1.InteractionResponseType.Modal,
+            data: modalData
+        });
+    }
+}
+exports.SelectMenuInteraction = SelectMenuInteraction;
+/**
+ * Modal submit interaction
+ */
+class ModalSubmitInteraction extends Interaction {
+    /** Modal custom ID */
+    customId;
+    /** Modal fields */
+    fields;
+    constructor(client, data) {
+        super(client, data);
+        this.customId = data.data?.custom_id || '';
+        // Modal values come from components array (action rows containing text inputs)
+        const components = data.data?.components || [];
+        this.fields = new ModalFields(components);
+    }
+}
+exports.ModalSubmitInteraction = ModalSubmitInteraction;
+/**
+ * Modal fields helper
+ */
+class ModalFields {
+    fieldMap;
+    constructor(components) {
+        this.fieldMap = new Map();
+        // Parse action rows → text inputs
+        for (const row of components) {
+            const innerComponents = row?.components || [];
+            for (const comp of innerComponents) {
+                if (comp.custom_id && comp.value !== undefined) {
+                    this.fieldMap.set(comp.custom_id, comp.value);
+                }
+            }
+        }
+    }
+    /**
+     * Get a text input value by custom_id
+     */
+    getTextInputValue(customId) {
+        return this.fieldMap.get(customId) ?? null;
+    }
+    /**
+     * Get a field (alias for getTextInputValue)
+     */
+    getField(customId) {
+        const value = this.fieldMap.get(customId);
+        return value !== undefined ? { value } : null;
+    }
+}
+exports.ModalFields = ModalFields;
+/**
+ * Create appropriate interaction class based on type
+ */
+function createInteraction(client, data) {
+    switch (data.type) {
+        case enums_1.InteractionType.ApplicationCommand:
+            return new CommandInteraction(client, data);
+        case enums_1.InteractionType.ApplicationCommandAutocomplete:
+            return new AutocompleteInteraction(client, data);
+        case enums_1.InteractionType.ModalSubmit:
+            return new ModalSubmitInteraction(client, data);
+        case enums_1.InteractionType.MessageComponent:
+            // component_type: 2 = Button, 3 = Select Menu
+            if (data.data?.component_type === 2) {
+                return new ButtonInteraction(client, data);
+            }
+            else if (data.data?.component_type === 3) {
+                return new SelectMenuInteraction(client, data);
+            }
+            return new Interaction(client, data);
+        default:
+            return new Interaction(client, data);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Interaction.js","sourceRoot":"","sources":["../../../src/structures/Interaction.ts"],"names":[],"mappings":";;;AA0fA,8CAmBC;AA5gBD,oCAAkF;AAClF,iCAA8B;AAC9B,+CAA4C;AAC5C,2DAAwD;AAGxD;;GAEG;AACH,MAAa,WAAW;IACtB,8BAA8B;IACd,MAAM,CAAS;IAE/B,qBAAqB;IACL,EAAE,CAAS;IAE3B,qBAAqB;IACL,aAAa,CAAS;IAEtC,uBAAuB;IACP,IAAI,CAAkB;IAEtC,eAAe;IACC,OAAO,CAAU;IAEjC,iBAAiB;IACD,SAAS,CAAU;IAEnC,wBAAwB;IACR,KAAK,CAAS;IAE9B,yCAAyC;IACzB,IAAI,CAAO;IAE3B,mCAAmC;IACnB,MAAM,CAAe;IAErC,kDAAkD;IAC3C,OAAO,GAAG,KAAK,CAAC;IAEvB,gDAAgD;IACzC,QAAQ,GAAG,KAAK,CAAC;IAExB,YAAY,MAAc,EAAE,IAAoB;QAC9C,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,oCAAoC;QACpC,IAAI,CAAC,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC1B,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QACjD,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QACjE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QACvE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QAExB,uDAAuD;QACvD,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,EAAE,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC;QAChD,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,WAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,WAAI,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;QAEvF,4BAA4B;QAC5B,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAChC,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAS,CAAC;YAC5F,IAAI,CAAC,MAAM,GAAG,IAAI,yBAAW,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QAC5D,CAAC;IACH,CAAC;IAED;;OAEG;IACH,SAAS;QACP,OAAO,IAAI,CAAC,IAAI,KAAK,uBAAe,CAAC,kBAAkB,CAAC;IAC1D,CAAC;IAED;;OAEG;IACH,cAAc;QACZ,OAAO,IAAI,CAAC,IAAI,KAAK,uBAAe,CAAC,8BAA8B,CAAC;IACtE,CAAC;IAED;;OAEG;IACH,aAAa;QACX,OAAO,IAAI,CAAC,IAAI,KAAK,uBAAe,CAAC,WAAW,CAAC;IACnD,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO,IAAI,CAAC,IAAI,KAAK,uBAAe,CAAC,gBAAgB,IAAK,IAAY,CAAC,aAAa,KAAK,CAAC,CAAC;IAC7F,CAAC;IAED;;OAEG;IACH,YAAY;QACV,OAAO,IAAI,CAAC,IAAI,KAAK,uBAAe,CAAC,gBAAgB,IAAK,IAAY,CAAC,aAAa,KAAK,CAAC,CAAC;IAC7F,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAK,CAAC,OAAyC;QACnD,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;QACzE,CAAC;QAED,MAAM,OAAO,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC;QACxE,MAAM,SAAS,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;QAC3E,MAAM,UAAU,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC;QAChF,MAAM,SAAS,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;QAE1E,kDAAkD;QAClD,MAAM,MAAM,GAAG,SAAS,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,YAAY,2BAAY,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAE/E,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE;YACpE,IAAI,EAAE,+BAAuB,CAAC,wBAAwB;YACtD,IAAI,EAAE;gBACJ,OAAO;gBACP,MAAM;gBACN,UAAU;gBACV,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,oBAAY,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;aAC9C;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,UAAU,CAAC,OAAiC;QAChD,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;QACzE,CAAC;QAED,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE;YACpE,IAAI,EAAE,+BAAuB,CAAC,gCAAgC;YAC9D,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,oBAAY,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,SAAS;SACzE,CAAC,CAAC;QAEH,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;IACvB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,SAAS,CAAC,OAAyC;QACvD,MAAM,OAAO,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC;QACxE,MAAM,SAAS,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;QAC3E,MAAM,UAAU,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC;QAChF,MAAM,KAAK,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;QAEtE,kDAAkD;QAClD,MAAM,MAAM,GAAG,SAAS,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,YAAY,2BAAY,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAE/E,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,KAAK,EAAE;YACzD,OAAO;YACP,MAAM;YACN,UAAU;YACV,KAAK;SACN,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,WAAW;QACf,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/D,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,QAAQ,CAAC,OAAyC;QACtD,MAAM,OAAO,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC;QACxE,MAAM,SAAS,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;QAC3E,MAAM,SAAS,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;QAE1E,kDAAkD;QAClD,MAAM,MAAM,GAAG,SAAS,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,YAAY,2BAAY,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAE/E,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE;YAChD,OAAO;YACP,MAAM;YACN,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,oBAAY,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;SAC9C,CAAC,CAAC;IACL,CAAC;CACF;AAnLD,kCAmLC;AAED;;GAEG;AACH,MAAa,kBAAmB,SAAQ,WAAW;IACjD,mBAAmB;IACH,WAAW,CAAS;IAEpC,sBAAsB;IACN,OAAO,CAA4B;IAEnD,YAAY,MAAc,EAAE,IAAoB;QAC9C,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACpB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC;QACzC,IAAI,CAAC,OAAO,GAAG,IAAI,yBAAyB,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,IAAI,EAAE,CAAC,CAAC;IACzE,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,SAAS,CAAC,KAA0C;QACxD,MAAM,SAAS,GAAG,QAAQ,IAAI,KAAK,IAAI,OAAO,KAAK,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;QACnG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE;YACpE,IAAI,EAAE,+BAAuB,CAAC,KAAK;YACnC,IAAI,EAAE,SAAS;SAChB,CAAC,CAAC;IACL,CAAC;CACF;AAvBD,gDAuBC;AAED;;GAEG;AACH,MAAa,yBAAyB;IAC5B,OAAO,CAAyB;IAExC,YAAY,OAA+B;QACzC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,IAAY,EAAE,QAAkB;QACxC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QACvD,IAAI,CAAC,MAAM,IAAI,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,oBAAoB,IAAI,aAAa,CAAC,CAAC;QAChF,OAAO,MAAM,EAAE,KAAe,IAAI,IAAI,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,UAAU,CAAC,IAAY,EAAE,QAAkB;QACzC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QACvD,IAAI,CAAC,MAAM,IAAI,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,oBAAoB,IAAI,aAAa,CAAC,CAAC;QAChF,OAAO,MAAM,EAAE,KAAe,IAAI,IAAI,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,IAAY,EAAE,QAAkB;QACxC,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,UAAU,CAAC,IAAY,EAAE,QAAkB;QACzC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QACvD,IAAI,CAAC,MAAM,IAAI,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,oBAAoB,IAAI,aAAa,CAAC,CAAC;QAChF,OAAO,MAAM,EAAE,KAAgB,IAAI,IAAI,CAAC;IAC1C,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,IAAY,EAAE,QAAkB;QACtC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QACvD,IAAI,CAAC,MAAM,IAAI,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,oBAAoB,IAAI,aAAa,CAAC,CAAC;QAChF,OAAO,MAAM,EAAE,KAAe,IAAI,IAAI,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,UAAU,CAAC,IAAY,EAAE,QAAkB;QACzC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QACvD,IAAI,CAAC,MAAM,IAAI,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,oBAAoB,IAAI,aAAa,CAAC,CAAC;QAChF,OAAO,MAAM,EAAE,KAAe,IAAI,IAAI,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,aAAa,CAAC,QAAkB;QAC9B,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC;QACpD,IAAI,CAAC,MAAM,IAAI,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;QAC1E,OAAO,MAAM,EAAE,IAAI,IAAI,IAAI,CAAC;IAC9B,CAAC;IAED;;OAEG;IACH,UAAU;QACR,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;QACjD,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC;QACzB,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,KAAe,EAAE,CAAC;IAC9D,CAAC;CACF;AA5ED,8DA4EC;AAED;;GAEG;AACH,MAAa,uBAAwB,SAAQ,WAAW;IACtD,mBAAmB;IACH,WAAW,CAAS;IAEpC,sBAAsB;IACN,OAAO,CAA4B;IAEnD,YAAY,MAAc,EAAE,IAAoB;QAC9C,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACpB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC;QACzC,IAAI,CAAC,OAAO,GAAG,IAAI,yBAAyB,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,IAAI,EAAE,CAAC,CAAC;IACzE,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAO,CAAC,OAA6B;QACzC,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE;YACpE,IAAI,EAAE,+BAAuB,CAAC,oCAAoC;YAClE,IAAI,EAAE,EAAE,OAAO,EAAE;SAClB,CAAC,CAAC;IACL,CAAC;CACF;AAtBD,0DAsBC;AAED;;GAEG;AACH,MAAa,iBAAkB,SAAQ,WAAW;IAChD,uBAAuB;IACP,QAAQ,CAAS;IAEjC,4CAA4C;IAC5B,aAAa,GAAW,CAAC,CAAC;IAE1C,wCAAwC;IACxB,OAAO,CAAO;IAE9B,YAAY,MAAc,EAAE,IAAoB;QAC9C,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACpB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,IAAI,EAAE,SAAS,IAAI,EAAE,CAAC;QAC3C,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;IAC9B,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,OAAgC;QAC3C,kDAAkD;QAClD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,YAAY,2BAAY,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAEpF,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE;YACpE,IAAI,EAAE,+BAAuB,CAAC,aAAa;YAC3C,IAAI,EAAE;gBACJ,OAAO,EAAE,OAAO,CAAC,OAAO;gBACxB,MAAM;gBACN,UAAU,EAAE,OAAO,CAAC,UAAU;aAC/B;SACF,CAAC,CAAC;QACH,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,SAAS,CAAC,KAA0C;QACxD,MAAM,SAAS,GAAG,QAAQ,IAAI,KAAK,IAAI,OAAO,KAAK,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;QACnG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE;YACpE,IAAI,EAAE,+BAAuB,CAAC,KAAK;YACnC,IAAI,EAAE,SAAS;SAChB,CAAC,CAAC;IACL,CAAC;CACF;AA5CD,8CA4CC;AAED;;GAEG;AACH,MAAa,qBAAsB,SAAQ,WAAW;IACpD,4BAA4B;IACZ,QAAQ,CAAS;IAEjC,iDAAiD;IACjC,aAAa,GAAW,CAAC,CAAC;IAE1C,sBAAsB;IACN,MAAM,CAAW;IAEjC,6CAA6C;IAC7B,OAAO,CAAO;IAE9B,YAAY,MAAc,EAAE,IAAoB;QAC9C,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACpB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,IAAI,EAAE,SAAS,IAAI,EAAE,CAAC;QAC3C,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,CAAC;QACtC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;IAC9B,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,OAAgC;QAC3C,kDAAkD;QAClD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,YAAY,2BAAY,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAEpF,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE;YACpE,IAAI,EAAE,+BAAuB,CAAC,aAAa;YAC3C,IAAI,EAAE;gBACJ,OAAO,EAAE,OAAO,CAAC,OAAO;gBACxB,MAAM;gBACN,UAAU,EAAE,OAAO,CAAC,UAAU;aAC/B;SACF,CAAC,CAAC;QACH,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,SAAS,CAAC,KAA0C;QACxD,MAAM,SAAS,GAAG,QAAQ,IAAI,KAAK,IAAI,OAAO,KAAK,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;QACnG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE;YACpE,IAAI,EAAE,+BAAuB,CAAC,KAAK;YACnC,IAAI,EAAE,SAAS;SAChB,CAAC,CAAC;IACL,CAAC;CACF;AAhDD,sDAgDC;AAED;;GAEG;AACH,MAAa,sBAAuB,SAAQ,WAAW;IACrD,sBAAsB;IACN,QAAQ,CAAS;IAEjC,mBAAmB;IACH,MAAM,CAAc;IAEpC,YAAY,MAAc,EAAE,IAAoB;QAC9C,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACpB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,IAAI,EAAE,SAAS,IAAI,EAAE,CAAC;QAC3C,+EAA+E;QAC/E,MAAM,UAAU,GAAI,IAAI,CAAC,IAAY,EAAE,UAAU,IAAI,EAAE,CAAC;QACxD,IAAI,CAAC,MAAM,GAAG,IAAI,WAAW,CAAC,UAAU,CAAC,CAAC;IAC5C,CAAC;CACF;AAdD,wDAcC;AAED;;GAEG;AACH,MAAa,WAAW;IACd,QAAQ,CAAsB;IAEtC,YAAY,UAAiB;QAC3B,IAAI,CAAC,QAAQ,GAAG,IAAI,GAAG,EAAE,CAAC;QAC1B,kCAAkC;QAClC,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;YAC7B,MAAM,eAAe,GAAG,GAAG,EAAE,UAAU,IAAI,EAAE,CAAC;YAC9C,KAAK,MAAM,IAAI,IAAI,eAAe,EAAE,CAAC;gBACnC,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;oBAC/C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;gBAChD,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACH,iBAAiB,CAAC,QAAgB;QAChC,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC;IAC7C,CAAC;IAED;;OAEG;IACH,QAAQ,CAAC,QAAgB;QACvB,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC1C,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;IAChD,CAAC;CACF;AA9BD,kCA8BC;AAsBD;;GAEG;AACH,SAAgB,iBAAiB,CAAC,MAAc,EAAE,IAAoB;IACpE,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,uBAAe,CAAC,kBAAkB;YACrC,OAAO,IAAI,kBAAkB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAC9C,KAAK,uBAAe,CAAC,8BAA8B;YACjD,OAAO,IAAI,uBAAuB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACnD,KAAK,uBAAe,CAAC,WAAW;YAC9B,OAAO,IAAI,sBAAsB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAClD,KAAK,uBAAe,CAAC,gBAAgB;YACnC,8CAA8C;YAC9C,IAAI,IAAI,CAAC,IAAI,EAAE,cAAc,KAAK,CAAC,EAAE,CAAC;gBACpC,OAAO,IAAI,iBAAiB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YAC7C,CAAC;iBAAM,IAAI,IAAI,CAAC,IAAI,EAAE,cAAc,KAAK,CAAC,EAAE,CAAC;gBAC3C,OAAO,IAAI,qBAAqB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YACjD,CAAC;YACD,OAAO,IAAI,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACvC;YACE,OAAO,IAAI,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACzC,CAAC;AACH,CAAC","sourcesContent":["import { APIInteraction, APIInteractionOption, APIEmbed } from '../types';\r\nimport { InteractionType, InteractionResponseType, MessageFlags } from '../enums';\r\nimport { User } from './User';\r\nimport { GuildMember } from './GuildMember';\r\nimport { EmbedBuilder } from '../builders/EmbedBuilder';\r\nimport type { Client } from '../Client';\r\n\r\n/**\r\n * Base interaction class\r\n */\r\nexport class Interaction {\r\n  /** Reference to the client */\r\n  public readonly client: Client;\r\n  \r\n  /** Interaction ID */\r\n  public readonly id: string;\r\n  \r\n  /** Application ID */\r\n  public readonly applicationId: string;\r\n  \r\n  /** Interaction type */\r\n  public readonly type: InteractionType;\r\n  \r\n  /** Guild ID */\r\n  public readonly guildId?: string;\r\n  \r\n  /** Channel ID */\r\n  public readonly channelId?: string;\r\n  \r\n  /** Interaction token */\r\n  public readonly token: string;\r\n  \r\n  /** User who triggered the interaction */\r\n  public readonly user: User;\r\n  \r\n  /** Guild member (if in a guild) */\r\n  public readonly member?: GuildMember;\r\n  \r\n  /** Whether the interaction has been replied to */\r\n  public replied = false;\r\n  \r\n  /** Whether the interaction has been deferred */\r\n  public deferred = false;\r\n\r\n  constructor(client: Client, data: APIInteraction) {\r\n    this.client = client;\r\n    // Handle both string and number IDs\r\n    this.id = String(data.id);\r\n    this.applicationId = String(data.application_id);\r\n    this.type = data.type;\r\n    this.guildId = data.guild_id ? String(data.guild_id) : undefined;\r\n    this.channelId = data.channel_id ? String(data.channel_id) : undefined;\r\n    this.token = data.token;\r\n    \r\n    // User can come from member.user or directly from user\r\n    const userData = data.member?.user || data.user;\r\n    this.user = userData ? new User(userData) : new User({ id: '0', username: 'Unknown' });\r\n    \r\n    // Create member if in guild\r\n    if (data.member && this.guildId) {\r\n      const guild = client.guilds.get(this.guildId) || { id: this.guildId, ownerId: null } as any;\r\n      this.member = new GuildMember(client, guild, data.member);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Check if this is a command interaction\r\n   */\r\n  isCommand(): this is CommandInteraction {\r\n    return this.type === InteractionType.ApplicationCommand;\r\n  }\r\n\r\n  /**\r\n   * Check if this is an autocomplete interaction\r\n   */\r\n  isAutocomplete(): this is AutocompleteInteraction {\r\n    return this.type === InteractionType.ApplicationCommandAutocomplete;\r\n  }\r\n\r\n  /**\r\n   * Check if this is a modal submit interaction\r\n   */\r\n  isModalSubmit(): this is ModalSubmitInteraction {\r\n    return this.type === InteractionType.ModalSubmit;\r\n  }\r\n\r\n  /**\r\n   * Check if this is a button interaction\r\n   */\r\n  isButton(): this is ButtonInteraction {\r\n    return this.type === InteractionType.MessageComponent && (this as any).componentType === 2;\r\n  }\r\n\r\n  /**\r\n   * Check if this is a select menu interaction\r\n   */\r\n  isSelectMenu(): this is SelectMenuInteraction {\r\n    return this.type === InteractionType.MessageComponent && (this as any).componentType === 3;\r\n  }\r\n\r\n  /**\r\n   * Reply to the interaction\r\n   */\r\n  async reply(options: string | InteractionReplyOptions): Promise<void> {\r\n    if (this.replied || this.deferred) {\r\n      throw new Error('Interaction has already been replied to or deferred');\r\n    }\r\n    \r\n    const content = typeof options === 'string' ? options : options.content;\r\n    const rawEmbeds = typeof options === 'string' ? undefined : options.embeds;\r\n    const components = typeof options === 'string' ? undefined : options.components;\r\n    const ephemeral = typeof options === 'string' ? false : options.ephemeral;\r\n    \r\n    // Convert EmbedBuilder instances to plain objects\r\n    const embeds = rawEmbeds?.map(e => e instanceof EmbedBuilder ? e.toJSON() : e);\r\n    \r\n    await this.client.rest.createInteractionResponse(this.id, this.token, {\r\n      type: InteractionResponseType.ChannelMessageWithSource,\r\n      data: {\r\n        content,\r\n        embeds,\r\n        components,\r\n        flags: ephemeral ? MessageFlags.Ephemeral : 0\r\n      }\r\n    });\r\n    \r\n    this.replied = true;\r\n  }\r\n\r\n  /**\r\n   * Defer the reply (shows \"thinking...\")\r\n   */\r\n  async deferReply(options?: { ephemeral?: boolean }): Promise<void> {\r\n    if (this.replied || this.deferred) {\r\n      throw new Error('Interaction has already been replied to or deferred');\r\n    }\r\n    \r\n    await this.client.rest.createInteractionResponse(this.id, this.token, {\r\n      type: InteractionResponseType.DeferredChannelMessageWithSource,\r\n      data: options?.ephemeral ? { flags: MessageFlags.Ephemeral } : undefined\r\n    });\r\n    \r\n    this.deferred = true;\r\n  }\r\n\r\n  /**\r\n   * Edit the reply\r\n   */\r\n  async editReply(options: string | InteractionReplyOptions): Promise<void> {\r\n    const content = typeof options === 'string' ? options : options.content;\r\n    const rawEmbeds = typeof options === 'string' ? undefined : options.embeds;\r\n    const components = typeof options === 'string' ? undefined : options.components;\r\n    const files = typeof options === 'string' ? undefined : options.files;\r\n    \r\n    // Convert EmbedBuilder instances to plain objects\r\n    const embeds = rawEmbeds?.map(e => e instanceof EmbedBuilder ? e.toJSON() : e);\r\n    \r\n    await this.client.rest.editInteractionResponse(this.token, {\r\n      content,\r\n      embeds,\r\n      components,\r\n      files\r\n    }, this.guildId, this.channelId, this.id);\r\n  }\r\n\r\n  /**\r\n   * Delete the reply\r\n   */\r\n  async deleteReply(): Promise<void> {\r\n    await this.client.rest.deleteInteractionResponse(this.token);\r\n  }\r\n\r\n  /**\r\n   * Send a followup message\r\n   */\r\n  async followUp(options: string | InteractionReplyOptions): Promise<void> {\r\n    const content = typeof options === 'string' ? options : options.content;\r\n    const rawEmbeds = typeof options === 'string' ? undefined : options.embeds;\r\n    const ephemeral = typeof options === 'string' ? false : options.ephemeral;\r\n    \r\n    // Convert EmbedBuilder instances to plain objects\r\n    const embeds = rawEmbeds?.map(e => e instanceof EmbedBuilder ? e.toJSON() : e);\r\n    \r\n    await this.client.rest.createFollowup(this.token, {\r\n      content,\r\n      embeds,\r\n      flags: ephemeral ? MessageFlags.Ephemeral : 0\r\n    });\r\n  }\r\n}\r\n\r\n/**\r\n * Command interaction\r\n */\r\nexport class CommandInteraction extends Interaction {\r\n  /** Command name */\r\n  public readonly commandName: string;\r\n  \r\n  /** Command options */\r\n  public readonly options: CommandInteractionOptions;\r\n\r\n  constructor(client: Client, data: APIInteraction) {\r\n    super(client, data);\r\n    this.commandName = data.data?.name || '';\r\n    this.options = new CommandInteractionOptions(data.data?.options || []);\r\n  }\r\n\r\n  /**\r\n   * Show a modal\r\n   */\r\n  async showModal(modal: ModalData | { toJSON(): ModalData }): Promise<void> {\r\n    const modalData = 'toJSON' in modal && typeof modal.toJSON === 'function' ? modal.toJSON() : modal;\r\n    await this.client.rest.createInteractionResponse(this.id, this.token, {\r\n      type: InteractionResponseType.Modal,\r\n      data: modalData\r\n    });\r\n  }\r\n}\r\n\r\n/**\r\n * Command interaction options helper\r\n */\r\nexport class CommandInteractionOptions {\r\n  private options: APIInteractionOption[];\r\n\r\n  constructor(options: APIInteractionOption[]) {\r\n    this.options = options;\r\n  }\r\n\r\n  /**\r\n   * Get a string option\r\n   */\r\n  getString(name: string, required?: boolean): string | null {\r\n    const option = this.options.find(o => o.name === name);\r\n    if (!option && required) throw new Error(`Required option \"${name}\" not found`);\r\n    return option?.value as string || null;\r\n  }\r\n\r\n  /**\r\n   * Get an integer option\r\n   */\r\n  getInteger(name: string, required?: boolean): number | null {\r\n    const option = this.options.find(o => o.name === name);\r\n    if (!option && required) throw new Error(`Required option \"${name}\" not found`);\r\n    return option?.value as number || null;\r\n  }\r\n\r\n  /**\r\n   * Get a number option\r\n   */\r\n  getNumber(name: string, required?: boolean): number | null {\r\n    return this.getInteger(name, required);\r\n  }\r\n\r\n  /**\r\n   * Get a boolean option\r\n   */\r\n  getBoolean(name: string, required?: boolean): boolean | null {\r\n    const option = this.options.find(o => o.name === name);\r\n    if (!option && required) throw new Error(`Required option \"${name}\" not found`);\r\n    return option?.value as boolean ?? null;\r\n  }\r\n\r\n  /**\r\n   * Get a user option\r\n   */\r\n  getUser(name: string, required?: boolean): string | null {\r\n    const option = this.options.find(o => o.name === name);\r\n    if (!option && required) throw new Error(`Required option \"${name}\" not found`);\r\n    return option?.value as string || null;\r\n  }\r\n\r\n  /**\r\n   * Get a channel option\r\n   */\r\n  getChannel(name: string, required?: boolean): string | null {\r\n    const option = this.options.find(o => o.name === name);\r\n    if (!option && required) throw new Error(`Required option \"${name}\" not found`);\r\n    return option?.value as string || null;\r\n  }\r\n\r\n  /**\r\n   * Get a subcommand name\r\n   */\r\n  getSubcommand(required?: boolean): string | null {\r\n    const option = this.options.find(o => o.type === 1);\r\n    if (!option && required) throw new Error('Required subcommand not found');\r\n    return option?.name || null;\r\n  }\r\n\r\n  /**\r\n   * Get the focused option (for autocomplete)\r\n   */\r\n  getFocused(): { name: string; value: string } | null {\r\n    const option = this.options.find(o => o.focused);\r\n    if (!option) return null;\r\n    return { name: option.name, value: option.value as string };\r\n  }\r\n}\r\n\r\n/**\r\n * Autocomplete interaction\r\n */\r\nexport class AutocompleteInteraction extends Interaction {\r\n  /** Command name */\r\n  public readonly commandName: string;\r\n  \r\n  /** Command options */\r\n  public readonly options: CommandInteractionOptions;\r\n\r\n  constructor(client: Client, data: APIInteraction) {\r\n    super(client, data);\r\n    this.commandName = data.data?.name || '';\r\n    this.options = new CommandInteractionOptions(data.data?.options || []);\r\n  }\r\n\r\n  /**\r\n   * Respond with autocomplete choices\r\n   */\r\n  async respond(choices: AutocompleteChoice[]): Promise<void> {\r\n    await this.client.rest.createInteractionResponse(this.id, this.token, {\r\n      type: InteractionResponseType.ApplicationCommandAutocompleteResult,\r\n      data: { choices }\r\n    });\r\n  }\r\n}\r\n\r\n/**\r\n * Button interaction\r\n */\r\nexport class ButtonInteraction extends Interaction {\r\n  /** Button custom ID */\r\n  public readonly customId: string;\r\n  \r\n  /** Component type (always 2 for buttons) */\r\n  public readonly componentType: number = 2;\r\n  \r\n  /** Message the button is attached to */\r\n  public readonly message?: any;\r\n\r\n  constructor(client: Client, data: APIInteraction) {\r\n    super(client, data);\r\n    this.customId = data.data?.custom_id || '';\r\n    this.message = data.message;\r\n  }\r\n\r\n  /**\r\n   * Update the message the button is attached to\r\n   */\r\n  async update(options: InteractionReplyOptions): Promise<void> {\r\n    // Convert EmbedBuilder instances to plain objects\r\n    const embeds = options.embeds?.map(e => e instanceof EmbedBuilder ? e.toJSON() : e);\r\n    \r\n    await this.client.rest.createInteractionResponse(this.id, this.token, {\r\n      type: InteractionResponseType.UpdateMessage,\r\n      data: {\r\n        content: options.content,\r\n        embeds,\r\n        components: options.components\r\n      }\r\n    });\r\n    this.replied = true;\r\n  }\r\n\r\n  /**\r\n   * Show a modal in response to this button interaction\r\n   */\r\n  async showModal(modal: ModalData | { toJSON(): ModalData }): Promise<void> {\r\n    const modalData = 'toJSON' in modal && typeof modal.toJSON === 'function' ? modal.toJSON() : modal;\r\n    await this.client.rest.createInteractionResponse(this.id, this.token, {\r\n      type: InteractionResponseType.Modal,\r\n      data: modalData\r\n    });\r\n  }\r\n}\r\n\r\n/**\r\n * Select menu interaction\r\n */\r\nexport class SelectMenuInteraction extends Interaction {\r\n  /** Select menu custom ID */\r\n  public readonly customId: string;\r\n  \r\n  /** Component type (always 3 for select menus) */\r\n  public readonly componentType: number = 3;\r\n  \r\n  /** Selected values */\r\n  public readonly values: string[];\r\n  \r\n  /** Message the select menu is attached to */\r\n  public readonly message?: any;\r\n\r\n  constructor(client: Client, data: APIInteraction) {\r\n    super(client, data);\r\n    this.customId = data.data?.custom_id || '';\r\n    this.values = data.data?.values || [];\r\n    this.message = data.message;\r\n  }\r\n\r\n  /**\r\n   * Update the message the select menu is attached to\r\n   */\r\n  async update(options: InteractionReplyOptions): Promise<void> {\r\n    // Convert EmbedBuilder instances to plain objects\r\n    const embeds = options.embeds?.map(e => e instanceof EmbedBuilder ? e.toJSON() : e);\r\n    \r\n    await this.client.rest.createInteractionResponse(this.id, this.token, {\r\n      type: InteractionResponseType.UpdateMessage,\r\n      data: {\r\n        content: options.content,\r\n        embeds,\r\n        components: options.components\r\n      }\r\n    });\r\n    this.replied = true;\r\n  }\r\n\r\n  /**\r\n   * Show a modal in response to this select menu interaction\r\n   */\r\n  async showModal(modal: ModalData | { toJSON(): ModalData }): Promise<void> {\r\n    const modalData = 'toJSON' in modal && typeof modal.toJSON === 'function' ? modal.toJSON() : modal;\r\n    await this.client.rest.createInteractionResponse(this.id, this.token, {\r\n      type: InteractionResponseType.Modal,\r\n      data: modalData\r\n    });\r\n  }\r\n}\r\n\r\n/**\r\n * Modal submit interaction\r\n */\r\nexport class ModalSubmitInteraction extends Interaction {\r\n  /** Modal custom ID */\r\n  public readonly customId: string;\r\n  \r\n  /** Modal fields */\r\n  public readonly fields: ModalFields;\r\n\r\n  constructor(client: Client, data: APIInteraction) {\r\n    super(client, data);\r\n    this.customId = data.data?.custom_id || '';\r\n    // Modal values come from components array (action rows containing text inputs)\r\n    const components = (data.data as any)?.components || [];\r\n    this.fields = new ModalFields(components);\r\n  }\r\n}\r\n\r\n/**\r\n * Modal fields helper\r\n */\r\nexport class ModalFields {\r\n  private fieldMap: Map<string, string>;\r\n\r\n  constructor(components: any[]) {\r\n    this.fieldMap = new Map();\r\n    // Parse action rows → text inputs\r\n    for (const row of components) {\r\n      const innerComponents = row?.components || [];\r\n      for (const comp of innerComponents) {\r\n        if (comp.custom_id && comp.value !== undefined) {\r\n          this.fieldMap.set(comp.custom_id, comp.value);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get a text input value by custom_id\r\n   */\r\n  getTextInputValue(customId: string): string | null {\r\n    return this.fieldMap.get(customId) ?? null;\r\n  }\r\n\r\n  /**\r\n   * Get a field (alias for getTextInputValue)\r\n   */\r\n  getField(customId: string): { value: string } | null {\r\n    const value = this.fieldMap.get(customId);\r\n    return value !== undefined ? { value } : null;\r\n  }\r\n}\r\n\r\n// Types\r\nexport interface InteractionReplyOptions {\r\n  content?: string;\r\n  embeds?: (APIEmbed | EmbedBuilder)[];\r\n  components?: any[];\r\n  ephemeral?: boolean;\r\n  files?: Array<{ name: string; data: Buffer; contentType?: string }>;\r\n}\r\n\r\nexport interface AutocompleteChoice {\r\n  name: string;\r\n  value: string | number;\r\n}\r\n\r\nexport interface ModalData {\r\n  custom_id: string;\r\n  title: string;\r\n  components: any[];\r\n}\r\n\r\n/**\r\n * Create appropriate interaction class based on type\r\n */\r\nexport function createInteraction(client: Client, data: APIInteraction): Interaction {\r\n  switch (data.type) {\r\n    case InteractionType.ApplicationCommand:\r\n      return new CommandInteraction(client, data);\r\n    case InteractionType.ApplicationCommandAutocomplete:\r\n      return new AutocompleteInteraction(client, data);\r\n    case InteractionType.ModalSubmit:\r\n      return new ModalSubmitInteraction(client, data);\r\n    case InteractionType.MessageComponent:\r\n      // component_type: 2 = Button, 3 = Select Menu\r\n      if (data.data?.component_type === 2) {\r\n        return new ButtonInteraction(client, data);\r\n      } else if (data.data?.component_type === 3) {\r\n        return new SelectMenuInteraction(client, data);\r\n      }\r\n      return new Interaction(client, data);\r\n    default:\r\n      return new Interaction(client, data);\r\n  }\r\n}\r\n"]}

package/dist/cjs/structures/Message.d.ts

@@ -0,0 +1,98 @@
+import { APIMessage, APIEmbed, APIAttachment } from '../types';
+import { User } from './User';
+import { GuildMember } from './GuildMember';
+import type { Client } from '../Client';
+import type { MessageCreateOptions } from './Channel';
+import { InteractionCollector, InteractionCollectorOptions } from '../utils/Collector';
+/**
+ * Mention data from backend
+ */
+export interface MessageMentions {
+    users?: Array<{
+        id: number | string;
+        username: string;
+    }>;
+    roles?: Array<{
+        id: string;
+        name?: string;
+    }>;
+    everyone?: boolean;
+}
+/**
+ * Represents a message
+ */
+export declare class Message {
+    /** Reference to the client */
+    readonly client: Client;
+    /** Message ID */
+    readonly id: string;
+    /** Channel ID */
+    readonly channelId: string;
+    /** Guild ID (if in a guild) */
+    readonly guildId?: string;
+    /** Message author */
+    readonly author: User;
+    /** Message content */
+    content: string;
+    /** Message timestamp */
+    readonly createdTimestamp: number;
+    /** Edit timestamp */
+    editedTimestamp?: number;
+    /** Attachments */
+    attachments: APIAttachment[];
+    /** Embeds */
+    embeds: APIEmbed[];
+    /** Components (buttons, select menus, etc.) */
+    components: any[];
+    /** Mentions in the message */
+    mentions: MessageMentions;
+    /** User ID (from backend) */
+    user_id?: number;
+    /** Guild member (if in a guild) */
+    member?: GuildMember;
+    constructor(client: Client, data: APIMessage);
+    /**
+     * Get the creation date
+     */
+    get createdAt(): Date;
+    /**
+     * Get the edit date
+     */
+    get editedAt(): Date | null;
+    /**
+     * Reply to this message
+     */
+    reply(options: string | MessageCreateOptions): Promise<Message>;
+    /**
+     * Edit this message (only if author is the bot)
+     */
+    edit(options: string | MessageCreateOptions): Promise<Message>;
+    /**
+     * Delete this message
+     */
+    delete(): Promise<void>;
+    /**
+     * React to this message
+     */
+    react(emoji: string): Promise<void>;
+    /**
+     * Pin this message
+     */
+    pin(): Promise<void>;
+    /**
+     * Unpin this message
+     */
+    unpin(): Promise<void>;
+    /**
+     * Create a component interaction collector on this message
+     */
+    createMessageComponentCollector(options?: Omit<InteractionCollectorOptions, 'messageId'>): InteractionCollector;
+    /**
+     * Await component interactions on this message
+     */
+    awaitMessageComponent(options?: Omit<InteractionCollectorOptions, 'messageId' | 'max'>): Promise<any>;
+    /**
+     * Convert to string
+     */
+    toString(): string;
+}