@minesa-org/mini-interaction 0.0.1

package/dist/index.js

@@ -0,0 +1,9 @@
+/** Entry point re-exporting MiniInteraction helpers, builders, and shared types. */
+export { MiniInteraction } from "./clients/MiniInteraction.js";
+export { CommandBuilder, CommandContext, IntegrationType, } from "./commands/CommandBuilder.js";
+export { CommandInteractionOptionResolver, createCommandInteraction, } from "./utils/CommandInteractionOptions.js";
+export { RoleConnectionMetadataTypes } from "./types/RoleConnectionMetadataTypes.js";
+export { ChannelType } from "./types/ChannelType.js";
+export { InteractionFollowUpFlags, InteractionReplyFlags, } from "./types/InteractionFlags.js";
+export { ButtonStyle } from "./types/ButtonStyle.js";
+export * from "./builders/index.js";

package/dist/types/ButtonStyle.d.ts

@@ -0,0 +1,16 @@
+/** Visual styles for Discord buttons matching the public API values. */
+export declare enum ButtonStyle {
+    /** The most prominent option in a set of actions. */
+    Primary = 1,
+    /** A neutral action that complements the primary action. */
+    Secondary = 2,
+    /** Indicates a successful or positive action. */
+    Success = 3,
+    /** Highlights a potentially destructive action. */
+    Danger = 4,
+    /** Navigates the user to an external URL. */
+    Link = 5,
+    /** Initiates a premium purchase flow. */
+    Premium = 6
+}
+export default ButtonStyle;

package/dist/types/ButtonStyle.js

@@ -0,0 +1,17 @@
+/** Visual styles for Discord buttons matching the public API values. */
+export var ButtonStyle;
+(function (ButtonStyle) {
+    /** The most prominent option in a set of actions. */
+    ButtonStyle[ButtonStyle["Primary"] = 1] = "Primary";
+    /** A neutral action that complements the primary action. */
+    ButtonStyle[ButtonStyle["Secondary"] = 2] = "Secondary";
+    /** Indicates a successful or positive action. */
+    ButtonStyle[ButtonStyle["Success"] = 3] = "Success";
+    /** Highlights a potentially destructive action. */
+    ButtonStyle[ButtonStyle["Danger"] = 4] = "Danger";
+    /** Navigates the user to an external URL. */
+    ButtonStyle[ButtonStyle["Link"] = 5] = "Link";
+    /** Initiates a premium purchase flow. */
+    ButtonStyle[ButtonStyle["Premium"] = 6] = "Premium";
+})(ButtonStyle || (ButtonStyle = {}));
+export default ButtonStyle;

package/dist/types/ChannelType.d.ts

@@ -0,0 +1,2 @@
+/** Re-export of Discord channel type identifiers for convenience in builders. */
+export { ChannelType } from "discord-api-types/v10";

package/dist/types/ChannelType.js

@@ -0,0 +1,2 @@
+/** Re-export of Discord channel type identifiers for convenience in builders. */
+export { ChannelType } from "discord-api-types/v10";

package/dist/types/Commands.d.ts

@@ -0,0 +1,11 @@
+import type { APIInteractionResponse, RESTPostAPIChatInputApplicationCommandsJSONBody } from "discord-api-types/v10";
+import type { CommandInteraction } from "../utils/CommandInteractionOptions.js";
+/** Handler signature for slash command executions within MiniInteraction. */
+export type SlashCommandHandler = (interaction: CommandInteraction) => Promise<APIInteractionResponse | void> | APIInteractionResponse | void;
+/** Structure representing a slash command definition and its runtime handler. */
+export type MiniInteractionCommand = {
+    data: RESTPostAPIChatInputApplicationCommandsJSONBody;
+    handler: SlashCommandHandler;
+};
+/** Map of command names to their registered MiniInteraction command definitions. */
+export type MiniInteractionCommandsMap = Map<string, MiniInteractionCommand>;

package/dist/types/Commands.js

@@ -0,0 +1 @@
+export {};

package/dist/types/ComponentTypes.d.ts

@@ -0,0 +1,5 @@
+import type { APIComponentInActionRow, APIComponentInMessageActionRow } from "discord-api-types/v10";
+/** * Components that can appear inside a Discord action row container. */
+export type MiniComponentMessageActionRow = APIComponentInMessageActionRow;
+/** Components that are valid inside message action rows. */
+export type MiniComponentActionRow = APIComponentInActionRow;

package/dist/types/ComponentTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/types/InteractionFlags.d.ts

@@ -0,0 +1,10 @@
+/** Flags available when responding directly to an interaction. */
+export declare enum InteractionReplyFlags {
+    Ephemeral = 64,
+    IsComponentsV2 = 32768
+}
+/** Flags available when sending a follow-up message for an interaction. */
+export declare enum InteractionFollowUpFlags {
+    Ephemeral = 64,
+    IsComponentsV2 = 32768
+}

package/dist/types/InteractionFlags.js

@@ -0,0 +1,12 @@
+/** Flags available when responding directly to an interaction. */
+export var InteractionReplyFlags;
+(function (InteractionReplyFlags) {
+    InteractionReplyFlags[InteractionReplyFlags["Ephemeral"] = 64] = "Ephemeral";
+    InteractionReplyFlags[InteractionReplyFlags["IsComponentsV2"] = 32768] = "IsComponentsV2";
+})(InteractionReplyFlags || (InteractionReplyFlags = {}));
+/** Flags available when sending a follow-up message for an interaction. */
+export var InteractionFollowUpFlags;
+(function (InteractionFollowUpFlags) {
+    InteractionFollowUpFlags[InteractionFollowUpFlags["Ephemeral"] = 64] = "Ephemeral";
+    InteractionFollowUpFlags[InteractionFollowUpFlags["IsComponentsV2"] = 32768] = "IsComponentsV2";
+})(InteractionFollowUpFlags || (InteractionFollowUpFlags = {}));

package/dist/types/RoleConnectionMetadataTypes.d.ts

@@ -0,0 +1,11 @@
+/** Enumerates available role connection metadata comparison types supported by Discord. */
+export declare enum RoleConnectionMetadataTypes {
+    IntegerLessThanOrEqual = 1,
+    IntegerGreaterThanOrEqual = 2,
+    IntegerEqual = 3,
+    IntegerNotEqual = 4,
+    DateTimeLessThanOrEqual = 5,
+    DateTimeGreaterThanOrEqual = 6,
+    BooleanEqual = 7,
+    BooleanNotEqual = 8
+}

package/dist/types/RoleConnectionMetadataTypes.js

@@ -0,0 +1,12 @@
+/** Enumerates available role connection metadata comparison types supported by Discord. */
+export var RoleConnectionMetadataTypes;
+(function (RoleConnectionMetadataTypes) {
+    RoleConnectionMetadataTypes[RoleConnectionMetadataTypes["IntegerLessThanOrEqual"] = 1] = "IntegerLessThanOrEqual";
+    RoleConnectionMetadataTypes[RoleConnectionMetadataTypes["IntegerGreaterThanOrEqual"] = 2] = "IntegerGreaterThanOrEqual";
+    RoleConnectionMetadataTypes[RoleConnectionMetadataTypes["IntegerEqual"] = 3] = "IntegerEqual";
+    RoleConnectionMetadataTypes[RoleConnectionMetadataTypes["IntegerNotEqual"] = 4] = "IntegerNotEqual";
+    RoleConnectionMetadataTypes[RoleConnectionMetadataTypes["DateTimeLessThanOrEqual"] = 5] = "DateTimeLessThanOrEqual";
+    RoleConnectionMetadataTypes[RoleConnectionMetadataTypes["DateTimeGreaterThanOrEqual"] = 6] = "DateTimeGreaterThanOrEqual";
+    RoleConnectionMetadataTypes[RoleConnectionMetadataTypes["BooleanEqual"] = 7] = "BooleanEqual";
+    RoleConnectionMetadataTypes[RoleConnectionMetadataTypes["BooleanNotEqual"] = 8] = "BooleanNotEqual";
+})(RoleConnectionMetadataTypes || (RoleConnectionMetadataTypes = {}));

package/dist/utils/CommandInteractionOptions.d.ts

@@ -0,0 +1,143 @@
+import { type APIInteractionResponse, type APIApplicationCommandInteractionDataOption, type APIChatInputApplicationCommandInteraction, type APIInteractionDataResolved, type APIInteractionDataResolvedChannel, type APIInteractionDataResolvedGuildMember, type APIModalInteractionResponse, type APIModalInteractionResponseCallbackData, type APIInteractionResponseChannelMessageWithSource, type APIInteractionResponseDeferredChannelMessageWithSource, type APIInteractionResponseUpdateMessage, type APIRole, type APIUser, type APIAttachment } from "discord-api-types/v10";
+import { DeferReplyOptions, InteractionMessageData } from "./interactionMessageHelpers.js";
+export type ResolvedUserOption = {
+    user: APIUser;
+    member?: APIInteractionDataResolvedGuildMember;
+};
+export type MentionableOption = {
+    type: "user";
+    value: ResolvedUserOption;
+} | {
+    type: "role";
+    value: APIRole;
+};
+/**
+ * Provides ergonomic helpers for extracting typed command options from Discord interactions.
+ */
+export declare class CommandInteractionOptionResolver {
+    readonly raw: ReadonlyArray<APIApplicationCommandInteractionDataOption>;
+    private readonly resolved;
+    private readonly focusedOptions;
+    private readonly subcommand;
+    private readonly subcommandGroup;
+    /**
+     * Creates a new resolver from raw interaction options.
+     *
+     * @param options - The raw options provided by Discord.
+     * @param resolved - The resolved data map included with the interaction payload.
+     */
+    constructor(options: APIApplicationCommandInteractionDataOption[] | undefined, resolved: APIInteractionDataResolved | undefined);
+    /**
+     * Retrieves the subcommand invoked by the user.
+     *
+     * @param required - Whether to throw when the subcommand is missing.
+     */
+    getSubcommand(required?: boolean): string | null;
+    /**
+     * Retrieves the subcommand group invoked by the user.
+     *
+     * @param required - Whether to throw when the subcommand group is missing.
+     */
+    getSubcommandGroup(required?: boolean): string | null;
+    /**
+     * Looks up a string option by name.
+     *
+     * @param name - The option name to resolve.
+     * @param required - Whether to throw when the option is missing.
+     */
+    getString(name: string, required?: boolean): string | null;
+    /**
+     * Looks up a numeric option by name.
+     *
+     * @param name - The option name to resolve.
+     * @param required - Whether to throw when the option is missing.
+     */
+    getNumber(name: string, required?: boolean): number | null;
+    /**
+     * Resolves a user option, including any guild member payload.
+     *
+     * @param name - The option name to resolve.
+     * @param required - Whether to throw when the option is missing or cannot be resolved.
+     */
+    getUser(name: string, required?: boolean): ResolvedUserOption | null;
+    /**
+     * Resolves a role option to its resolved payload.
+     *
+     * @param name - The option name to resolve.
+     * @param required - Whether to throw when the option is missing or cannot be resolved.
+     */
+    getRole(name: string, required?: boolean): APIRole | null;
+    /**
+     * Resolves a channel option to its resolved payload.
+     *
+     * @param name - The option name to resolve.
+     * @param required - Whether to throw when the option is missing or cannot be resolved.
+     */
+    getChannel(name: string, required?: boolean): APIInteractionDataResolvedChannel | null;
+    /**
+     * Resolves an attachment option to its resolved payload.
+     *
+     * @param name - The option name to resolve.
+     * @param required - Whether to throw when the option is missing or cannot be resolved.
+     */
+    getAttachment(name: string, required?: boolean): APIAttachment | null;
+    /**
+     * Resolves a mentionable option to either a role or user payload.
+     *
+     * @param name - The option name to resolve.
+     * @param required - Whether to throw when the option is missing or cannot be resolved.
+     */
+    getMentionable(name: string, required?: boolean): MentionableOption | null;
+    /**
+     * Returns the raw option payload, bypassing type checks and casting.
+     *
+     * @param name - The option name to look up.
+     */
+    getRawOption(name: string): APIApplicationCommandInteractionDataOption | null;
+    /**
+     * Extracts a strongly typed option, ensuring it exists and matches the expected type.
+     */
+    private extractOption;
+    /**
+     * Resolves an attachment by identifier from the interaction's resolved payloads.
+     */
+    private resolveAttachment;
+    /**
+     * Resolves a channel by identifier from the interaction's resolved payloads.
+     */
+    private resolveChannel;
+    /**
+     * Resolves a role by identifier from the interaction's resolved payloads.
+     */
+    private resolveRole;
+    /**
+     * Resolves a user and optional member by identifier from the interaction's resolved payloads.
+     */
+    private resolveUser;
+    /**
+     * Retrieves a record from a resolved payload map by identifier.
+     */
+    private getResolvedRecord;
+}
+/**
+ * Represents a command interaction augmented with helper methods for easy responses.
+ */
+export interface CommandInteraction extends Omit<APIChatInputApplicationCommandInteraction, "data"> {
+    data: Omit<APIChatInputApplicationCommandInteraction["data"], "options"> & {
+        options: CommandInteractionOptionResolver;
+    };
+    options: CommandInteractionOptionResolver;
+    getResponse(): APIInteractionResponse | null;
+    reply(data: InteractionMessageData): APIInteractionResponseChannelMessageWithSource;
+    followUp(data: InteractionMessageData): APIInteractionResponseChannelMessageWithSource;
+    edit(data?: InteractionMessageData): APIInteractionResponseUpdateMessage;
+    deferReply(options?: DeferReplyOptions): APIInteractionResponseDeferredChannelMessageWithSource;
+    showModal(data: APIModalInteractionResponseCallbackData): APIModalInteractionResponse;
+}
+/**
+ * Wraps a raw application command interaction with helper methods and option resolvers.
+ *
+ * @param interaction - The raw interaction payload from Discord.
+ * @returns A helper-augmented interaction object.
+ */
+export declare function createCommandInteraction(interaction: APIChatInputApplicationCommandInteraction): CommandInteraction;

package/dist/utils/CommandInteractionOptions.js

@@ -0,0 +1,376 @@
+import { ApplicationCommandOptionType, InteractionResponseType, } from "discord-api-types/v10";
+import { normaliseInteractionMessageData, normaliseMessageFlags, } from "./interactionMessageHelpers.js";
+/** Maps application command option types to human-readable labels for error messages. */
+const OPTION_TYPE_LABEL = {
+    [ApplicationCommandOptionType.Subcommand]: "subcommand",
+    [ApplicationCommandOptionType.SubcommandGroup]: "subcommand group",
+    [ApplicationCommandOptionType.String]: "string",
+    [ApplicationCommandOptionType.Integer]: "integer",
+    [ApplicationCommandOptionType.Boolean]: "boolean",
+    [ApplicationCommandOptionType.User]: "user",
+    [ApplicationCommandOptionType.Channel]: "channel",
+    [ApplicationCommandOptionType.Role]: "role",
+    [ApplicationCommandOptionType.Mentionable]: "mentionable",
+    [ApplicationCommandOptionType.Number]: "number",
+    [ApplicationCommandOptionType.Attachment]: "attachment",
+};
+/**
+ * Determines whether the provided option represents a subcommand.
+ *
+ * @param option - The option to inspect.
+ */
+function isSubcommandOption(option) {
+    return option.type === ApplicationCommandOptionType.Subcommand;
+}
+/**
+ * Determines whether the provided option represents a subcommand group.
+ *
+ * @param option - The option to inspect.
+ */
+function isSubcommandGroupOption(option) {
+    return option.type === ApplicationCommandOptionType.SubcommandGroup;
+}
+/**
+ * Extracts the most relevant option set from the raw command options hierarchy.
+ *
+ * @param options - The raw options array from the interaction payload.
+ * @returns The resolved subcommand context and focused options for convenience accessors.
+ */
+function resolveFocusedOptions(options) {
+    if (!options || options.length === 0) {
+        return { subcommandGroup: null, subcommand: null, options: [] };
+    }
+    const [firstOption] = options;
+    if (isSubcommandGroupOption(firstOption)) {
+        const [firstSubcommand] = firstOption.options ?? [];
+        if (firstSubcommand && isSubcommandOption(firstSubcommand)) {
+            return {
+                subcommandGroup: firstOption.name,
+                subcommand: firstSubcommand.name,
+                options: firstSubcommand.options ?? [],
+            };
+        }
+        return {
+            subcommandGroup: firstOption.name,
+            subcommand: null,
+            options: [],
+        };
+    }
+    if (isSubcommandOption(firstOption)) {
+        return {
+            subcommandGroup: null,
+            subcommand: firstOption.name,
+            options: firstOption.options ?? [],
+        };
+    }
+    return {
+        subcommandGroup: null,
+        subcommand: null,
+        options: options,
+    };
+}
+/**
+ * Provides ergonomic helpers for extracting typed command options from Discord interactions.
+ */
+export class CommandInteractionOptionResolver {
+    raw;
+    resolved;
+    focusedOptions;
+    subcommand;
+    subcommandGroup;
+    /**
+     * Creates a new resolver from raw interaction options.
+     *
+     * @param options - The raw options provided by Discord.
+     * @param resolved - The resolved data map included with the interaction payload.
+     */
+    constructor(options, resolved) {
+        this.raw = Object.freeze([...(options ?? [])]);
+        this.resolved = resolved;
+        const focused = resolveFocusedOptions(options);
+        this.focusedOptions = focused.options;
+        this.subcommand = focused.subcommand;
+        this.subcommandGroup = focused.subcommandGroup;
+    }
+    /**
+     * Retrieves the subcommand invoked by the user.
+     *
+     * @param required - Whether to throw when the subcommand is missing.
+     */
+    getSubcommand(required = true) {
+        if (this.subcommand) {
+            return this.subcommand;
+        }
+        if (required) {
+            throw new Error("Expected a subcommand to be present on this interaction");
+        }
+        return null;
+    }
+    /**
+     * Retrieves the subcommand group invoked by the user.
+     *
+     * @param required - Whether to throw when the subcommand group is missing.
+     */
+    getSubcommandGroup(required = true) {
+        if (this.subcommandGroup) {
+            return this.subcommandGroup;
+        }
+        if (required) {
+            throw new Error("Expected a subcommand group to be present on this interaction");
+        }
+        return null;
+    }
+    /**
+     * Looks up a string option by name.
+     *
+     * @param name - The option name to resolve.
+     * @param required - Whether to throw when the option is missing.
+     */
+    getString(name, required = false) {
+        const option = this.extractOption(name, ApplicationCommandOptionType.String, required);
+        return option ? option.value : null;
+    }
+    /**
+     * Looks up a numeric option by name.
+     *
+     * @param name - The option name to resolve.
+     * @param required - Whether to throw when the option is missing.
+     */
+    getNumber(name, required = false) {
+        const option = this.extractOption(name, ApplicationCommandOptionType.Number, required);
+        return option ? option.value : null;
+    }
+    /**
+     * Resolves a user option, including any guild member payload.
+     *
+     * @param name - The option name to resolve.
+     * @param required - Whether to throw when the option is missing or cannot be resolved.
+     */
+    getUser(name, required = false) {
+        const option = this.extractOption(name, ApplicationCommandOptionType.User, required);
+        if (!option) {
+            return null;
+        }
+        const resolvedUser = this.resolveUser(option.value);
+        if (!resolvedUser) {
+            if (required) {
+                throw new Error(`Resolved data for user option "${name}" is missing`);
+            }
+            return null;
+        }
+        return resolvedUser;
+    }
+    /**
+     * Resolves a role option to its resolved payload.
+     *
+     * @param name - The option name to resolve.
+     * @param required - Whether to throw when the option is missing or cannot be resolved.
+     */
+    getRole(name, required = false) {
+        const option = this.extractOption(name, ApplicationCommandOptionType.Role, required);
+        if (!option) {
+            return null;
+        }
+        const role = this.resolveRole(option.value);
+        if (!role && required) {
+            throw new Error(`Resolved data for role option "${name}" is missing`);
+        }
+        return role ?? null;
+    }
+    /**
+     * Resolves a channel option to its resolved payload.
+     *
+     * @param name - The option name to resolve.
+     * @param required - Whether to throw when the option is missing or cannot be resolved.
+     */
+    getChannel(name, required = false) {
+        const option = this.extractOption(name, ApplicationCommandOptionType.Channel, required);
+        if (!option) {
+            return null;
+        }
+        const channel = this.resolveChannel(option.value);
+        if (!channel && required) {
+            throw new Error(`Resolved data for channel option "${name}" is missing`);
+        }
+        return channel ?? null;
+    }
+    /**
+     * Resolves an attachment option to its resolved payload.
+     *
+     * @param name - The option name to resolve.
+     * @param required - Whether to throw when the option is missing or cannot be resolved.
+     */
+    getAttachment(name, required = false) {
+        const option = this.extractOption(name, ApplicationCommandOptionType.Attachment, required);
+        if (!option) {
+            return null;
+        }
+        const attachment = this.resolveAttachment(option.value);
+        if (!attachment && required) {
+            throw new Error(`Resolved data for attachment option "${name}" is missing`);
+        }
+        return attachment ?? null;
+    }
+    /**
+     * Resolves a mentionable option to either a role or user payload.
+     *
+     * @param name - The option name to resolve.
+     * @param required - Whether to throw when the option is missing or cannot be resolved.
+     */
+    getMentionable(name, required = false) {
+        const option = this.extractOption(name, ApplicationCommandOptionType.Mentionable, required);
+        if (!option) {
+            return null;
+        }
+        const role = this.resolveRole(option.value);
+        if (role) {
+            return { type: "role", value: role };
+        }
+        const user = this.resolveUser(option.value);
+        if (user) {
+            return { type: "user", value: user };
+        }
+        if (required) {
+            throw new Error(`Resolved data for mentionable option "${name}" is missing`);
+        }
+        return null;
+    }
+    /**
+     * Returns the raw option payload, bypassing type checks and casting.
+     *
+     * @param name - The option name to look up.
+     */
+    getRawOption(name) {
+        return (this.focusedOptions.find((option) => option.name === name) ?? null);
+    }
+    /**
+     * Extracts a strongly typed option, ensuring it exists and matches the expected type.
+     */
+    extractOption(name, type, required) {
+        const option = this.focusedOptions.find((candidate) => candidate.name === name);
+        if (!option) {
+            if (required) {
+                throw new Error(`Required ${OPTION_TYPE_LABEL[type]} option "${name}" is missing`);
+            }
+            return null;
+        }
+        if (option.type !== type) {
+            throw new Error(`Option "${name}" is a ${OPTION_TYPE_LABEL[option.type]}, expected ${OPTION_TYPE_LABEL[type]}`);
+        }
+        return option;
+    }
+    /**
+     * Resolves an attachment by identifier from the interaction's resolved payloads.
+     */
+    resolveAttachment(id) {
+        return this.getResolvedRecord(this.resolved?.attachments, id);
+    }
+    /**
+     * Resolves a channel by identifier from the interaction's resolved payloads.
+     */
+    resolveChannel(id) {
+        return this.getResolvedRecord(this.resolved?.channels, id);
+    }
+    /**
+     * Resolves a role by identifier from the interaction's resolved payloads.
+     */
+    resolveRole(id) {
+        return this.getResolvedRecord(this.resolved?.roles, id);
+    }
+    /**
+     * Resolves a user and optional member by identifier from the interaction's resolved payloads.
+     */
+    resolveUser(id) {
+        const user = this.getResolvedRecord(this.resolved?.users, id);
+        if (!user) {
+            return null;
+        }
+        const member = this.getResolvedRecord(this.resolved?.members, id);
+        return { user, member: member ?? undefined };
+    }
+    /**
+     * Retrieves a record from a resolved payload map by identifier.
+     */
+    getResolvedRecord(records, id) {
+        return records?.[id];
+    }
+}
+/**
+ * Wraps a raw application command interaction with helper methods and option resolvers.
+ *
+ * @param interaction - The raw interaction payload from Discord.
+ * @returns A helper-augmented interaction object.
+ */
+export function createCommandInteraction(interaction) {
+    const options = new CommandInteractionOptionResolver(interaction.data.options, interaction.data.resolved);
+    let capturedResponse = null;
+    /**
+     * Stores the most recent response helper payload for later retrieval.
+     */
+    const captureResponse = (response) => {
+        capturedResponse = response;
+        return response;
+    };
+    function createMessageResponse(type, data) {
+        const normalisedData = normaliseInteractionMessageData(data);
+        if (type === InteractionResponseType.ChannelMessageWithSource) {
+            if (!normalisedData) {
+                throw new Error("[MiniInteraction] Channel message responses require data to be provided.");
+            }
+            return captureResponse({
+                type,
+                data: normalisedData,
+            });
+        }
+        if (normalisedData) {
+            return captureResponse({ type, data: normalisedData });
+        }
+        return captureResponse({ type });
+    }
+    /**
+     * Creates a deferred response while normalising any helper flag values.
+     */
+    const createDeferredResponse = (data) => {
+        if (!data) {
+            return captureResponse({
+                type: InteractionResponseType.DeferredChannelMessageWithSource,
+            });
+        }
+        return captureResponse({
+            type: InteractionResponseType.DeferredChannelMessageWithSource,
+            data: { flags: normaliseMessageFlags(data.flags) },
+        });
+    };
+    const commandInteraction = {
+        ...interaction,
+        data: {
+            ...interaction.data,
+            options,
+        },
+        options,
+        getResponse() {
+            return capturedResponse;
+        },
+        reply(data) {
+            return createMessageResponse(InteractionResponseType.ChannelMessageWithSource, data);
+        },
+        followUp(data) {
+            return createMessageResponse(InteractionResponseType.ChannelMessageWithSource, data);
+        },
+        edit(data) {
+            return createMessageResponse(InteractionResponseType.UpdateMessage, data);
+        },
+        deferReply(options) {
+            return createDeferredResponse(options?.flags !== undefined
+                ? { flags: options.flags }
+                : undefined);
+        },
+        showModal(data) {
+            return captureResponse({
+                type: InteractionResponseType.Modal,
+                data,
+            });
+        },
+    };
+    return commandInteraction;
+}

package/dist/utils/MessageComponentInteraction.d.ts

@@ -0,0 +1,19 @@
+import { type APIInteractionResponse, type APIInteractionResponseChannelMessageWithSource, type APIInteractionResponseDeferredChannelMessageWithSource, type APIInteractionResponseDeferredMessageUpdate, type APIInteractionResponseUpdateMessage, type APIMessageComponentInteraction } from "discord-api-types/v10";
+import { DeferReplyOptions, InteractionMessageData } from "./interactionMessageHelpers.js";
+/**
+ * Represents a component interaction augmented with helper response methods.
+ */
+export type MessageComponentInteraction = APIMessageComponentInteraction & {
+    getResponse: () => APIInteractionResponse | null;
+    reply: (data: InteractionMessageData) => APIInteractionResponseChannelMessageWithSource;
+    deferReply: (options?: DeferReplyOptions) => APIInteractionResponseDeferredChannelMessageWithSource;
+    update: (data?: InteractionMessageData) => APIInteractionResponseUpdateMessage;
+    deferUpdate: () => APIInteractionResponseDeferredMessageUpdate;
+};
+/**
+ * Wraps a raw component interaction with helper methods mirroring Discord's expected responses.
+ *
+ * @param interaction - The raw interaction payload from Discord.
+ * @returns A helper-augmented interaction object.
+ */
+export declare function createMessageComponentInteraction(interaction: APIMessageComponentInteraction): MessageComponentInteraction;