@minesa-org/mini-interaction 0.4.1 → 0.4.4

package/dist/builders/ActionRowBuilder.d.ts

@@ -1,12 +1,11 @@
-import type { APIActionRowComponent } from "discord-api-types/v10";
 import type { JSONEncodable } from "./shared.js";
-import type { ActionRowComponent } from "../types/ComponentTypes.js";
+import type { ActionRowComponent, MiniActionRow } from "../types/ComponentTypes.js";
 /** Values accepted when composing component action rows. */
 export type ActionRowComponentLike<T extends ActionRowComponent> = JSONEncodable<T> | T;
 /** Builder for creating Action Row components. */
-export declare class ActionRowBuilder<T extends ActionRowComponent> implements JSONEncodable<APIActionRowComponent<T>> {
+export declare class ActionRowBuilder<T extends ActionRowComponent> implements JSONEncodable<MiniActionRow<T>> {
     private components;
-    constructor(data?: Partial<APIActionRowComponent<T>>);
+    constructor(data?: Partial<MiniActionRow<T>>);
     /**
      * Adds components to this action row.
      *
@@ -19,5 +18,5 @@ export declare class ActionRowBuilder<T extends ActionRowComponent> implements J
      * @param components - The new components to set.
      */
     setComponents(...components: (T | JSONEncodable<T>)[]): this;
-    toJSON(): APIActionRowComponent<T>;
+    toJSON(): MiniActionRow<T>;
 }

package/dist/builders/CheckboxBuilder.d.ts

@@ -0,0 +1,17 @@
+import type { JSONEncodable } from './shared.js';
+import { APICheckboxComponent, APICheckboxOption } from '../types/checkbox.js';
+export type CheckboxBuilderData = {
+    customId?: string;
+    required?: boolean;
+    disabled?: boolean;
+    options?: APICheckboxOption[];
+};
+export declare class CheckboxBuilder implements JSONEncodable<APICheckboxComponent> {
+    private readonly data;
+    constructor(data?: CheckboxBuilderData);
+    setCustomId(customId: string): this;
+    setRequired(required: boolean): this;
+    setDisabled(disabled: boolean): this;
+    addOptions(...options: APICheckboxOption[]): this;
+    toJSON(): APICheckboxComponent;
+}

package/dist/builders/CheckboxBuilder.js

@@ -0,0 +1,24 @@
+import { CHECKBOX_COMPONENT_TYPE } from '../types/checkbox.js';
+import { assertDefined, assertStringLength, ValidationError } from '../types/validation.js';
+export class CheckboxBuilder {
+    data;
+    constructor(data = {}) { this.data = { ...data, options: data.options ? [...data.options] : [] }; }
+    setCustomId(customId) { this.data.customId = customId; return this; }
+    setRequired(required) { this.data.required = required; return this; }
+    setDisabled(disabled) { this.data.disabled = disabled; return this; }
+    addOptions(...options) { this.data.options = [...(this.data.options ?? []), ...options]; return this; }
+    toJSON() {
+        const customId = assertDefined('CheckboxBuilder', 'custom_id', this.data.customId);
+        assertStringLength('CheckboxBuilder', 'custom_id', customId, 1, 100);
+        const options = [...(this.data.options ?? [])];
+        if (options.length === 0 || options.length > 25)
+            throw new ValidationError('CheckboxBuilder', 'options', 'must contain 1-25 options');
+        for (const [index, option] of options.entries()) {
+            assertStringLength('CheckboxBuilder', `options[${index}].label`, option.label, 1, 100);
+            assertStringLength('CheckboxBuilder', `options[${index}].value`, option.value, 1, 100);
+            if (option.description)
+                assertStringLength('CheckboxBuilder', `options[${index}].description`, option.description, 1, 100);
+        }
+        return { type: CHECKBOX_COMPONENT_TYPE, custom_id: customId, disabled: this.data.disabled, required: this.data.required, options };
+    }
+}

package/dist/builders/index.d.ts

@@ -38,3 +38,5 @@ export type { ContainerBuilderData, SectionBuilderData, TextDisplayBuilderData,
 export type { JSONEncodable } from "./shared.js";
 export { RadioBuilder } from "./RadioBuilder.js";
 export type { RadioBuilderData } from "./RadioBuilder.js";
+export { CheckboxBuilder } from "./CheckboxBuilder.js";
+export type { CheckboxBuilderData } from "./CheckboxBuilder.js";

package/dist/builders/index.js

@@ -18,3 +18,4 @@ export { AutomodRuleBuilder } from "./AutomodRuleBuilder.js";
 export { EmbedBuilder } from "./EmbedBuilder.js";
 export { ContainerBuilder, SectionBuilder, TextDisplayBuilder, SeparatorBuilder, GalleryBuilder, GalleryItemBuilder, ThumbnailBuilder, } from "./MiniContainerBuilder.js";
 export { RadioBuilder } from "./RadioBuilder.js";
+export { CheckboxBuilder } from "./CheckboxBuilder.js";

package/dist/compat/MiniInteraction.d.ts

@@ -0,0 +1,64 @@
+type TimeoutConfig = {
+    initialResponseTimeout?: number;
+    autoDeferSlowOperations?: boolean;
+    enableTimeoutWarnings?: boolean;
+    enableResponseDebugLogging?: boolean;
+};
+export type MiniInteractionOptions = {
+    commandsDirectory?: string;
+    componentsDirectory?: string;
+    utilsDirectory?: string;
+    timeoutConfig?: TimeoutConfig;
+    debug?: boolean;
+    cwd?: string;
+    publicKey?: string;
+    applicationId?: string;
+    token?: string;
+};
+type NodeRequest = {
+    body?: unknown;
+    rawBody?: string | Uint8Array | Buffer;
+    headers: Record<string, string | string[] | undefined> | {
+        get(name: string): string | null;
+    };
+    method?: string;
+    [Symbol.asyncIterator]?: () => AsyncIterableIterator<Uint8Array>;
+    on?: (event: string, listener: (...args: unknown[]) => void) => void;
+};
+type NodeResponse = {
+    statusCode?: number;
+    setHeader?: (name: string, value: string) => void;
+    end: (body?: string) => void;
+    status?: (code: number) => NodeResponse;
+    json?: (body: unknown) => void;
+};
+export declare class MiniInteraction {
+    private readonly options;
+    private readonly projectRoot;
+    private readonly rest;
+    private readonly responseStates;
+    private loadedModulesPromise?;
+    constructor(options?: MiniInteractionOptions);
+    createNodeHandler(): (req: NodeRequest, res: NodeResponse) => Promise<void>;
+    private dispatch;
+    private executeCommandHandler;
+    private executeComponentHandler;
+    private executeModalHandler;
+    private runWithResponseLifecycle;
+    private loadModules;
+    private discoverModules;
+    private loadDirectory;
+    private normalizeModuleExports;
+    private normalizeExportValue;
+    private walkFiles;
+    private isImportableModule;
+    private isInteractionCommand;
+    private getCommandName;
+    private isCustomIdHandler;
+    private looksLikeModalFile;
+    private readRawBody;
+    private getHeader;
+    private sendJson;
+}
+export declare const LegacyMiniInteractionAdapter: typeof MiniInteraction;
+export {};

package/dist/compat/MiniInteraction.js

@@ -0,0 +1,336 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { ApplicationCommandType, InteractionResponseType, InteractionType, } from "discord-api-types/v10";
+import { createCommandInteraction } from "../utils/CommandInteractionOptions.js";
+import { createAppCommandInteraction, createMessageContextMenuInteraction, createUserContextMenuInteraction, } from "../utils/ContextMenuInteraction.js";
+import { createMessageComponentInteraction } from "../utils/MessageComponentInteraction.js";
+import { createModalSubmitInteraction } from "../utils/ModalSubmitInteraction.js";
+import { DiscordRestClient } from "../core/http/DiscordRestClient.js";
+import { verifyAndParseInteraction } from "../core/interactions/InteractionVerifier.js";
+export class MiniInteraction {
+    options;
+    projectRoot;
+    rest;
+    responseStates = new Map();
+    loadedModulesPromise;
+    constructor(options = {}) {
+        this.options = options;
+        this.projectRoot = path.resolve(options.cwd ?? process.cwd());
+        const applicationId = options.applicationId ??
+            process.env.DISCORD_APPLICATION_ID ??
+            process.env.DISCORD_APP_ID;
+        const token = options.token ??
+            process.env.DISCORD_BOT_TOKEN ??
+            process.env.DISCORD_TOKEN;
+        if (!applicationId || !token) {
+            throw new Error("[MiniInteraction] Missing Discord REST credentials. Set applicationId/token or DISCORD_APPLICATION_ID + DISCORD_BOT_TOKEN.");
+        }
+        this.rest = new DiscordRestClient({ applicationId, token });
+    }
+    createNodeHandler() {
+        return async (req, res) => {
+            try {
+                const body = await this.readRawBody(req);
+                const signature = this.getHeader(req.headers, "x-signature-ed25519");
+                const timestamp = this.getHeader(req.headers, "x-signature-timestamp");
+                const publicKey = this.options.publicKey ?? process.env.DISCORD_PUBLIC_KEY;
+                if (!publicKey) {
+                    this.sendJson(res, 500, {
+                        error: "[MiniInteraction] Missing DISCORD_PUBLIC_KEY.",
+                    });
+                    return;
+                }
+                if (!signature || !timestamp) {
+                    this.sendJson(res, 401, {
+                        error: "[MiniInteraction] Missing Discord signature headers.",
+                    });
+                    return;
+                }
+                const interaction = await verifyAndParseInteraction({
+                    body,
+                    signature,
+                    timestamp,
+                    publicKey,
+                });
+                if (interaction.type === InteractionType.Ping) {
+                    this.sendJson(res, 200, { type: InteractionResponseType.Pong });
+                    return;
+                }
+                const response = await this.dispatch(interaction);
+                this.sendJson(res, 200, response ?? {
+                    type: InteractionResponseType.DeferredChannelMessageWithSource,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "[MiniInteraction] Unknown error";
+                if (this.options.debug) {
+                    console.error("[MiniInteraction] createNodeHandler failed", error);
+                }
+                this.sendJson(res, 500, { error: message });
+            }
+        };
+    }
+    async dispatch(interaction) {
+        const modules = await this.loadModules();
+        if (interaction.type === InteractionType.ApplicationCommand) {
+            const command = modules.commands.find((candidate) => this.getCommandName(candidate) === interaction.data.name);
+            if (!command)
+                return undefined;
+            return this.executeCommandHandler(command.handler, interaction);
+        }
+        if (interaction.type === InteractionType.MessageComponent) {
+            const component = modules.components.find((candidate) => candidate.customId === interaction.data.custom_id);
+            if (!component)
+                return undefined;
+            return this.executeComponentHandler(component.handler, interaction);
+        }
+        if (interaction.type === InteractionType.ModalSubmit) {
+            const modal = modules.modals.find((candidate) => candidate.customId === interaction.data.custom_id);
+            if (!modal)
+                return undefined;
+            return this.executeModalHandler(modal.handler, interaction);
+        }
+        return undefined;
+    }
+    async executeCommandHandler(handler, interaction) {
+        return this.runWithResponseLifecycle(interaction, async (helpers) => {
+            switch (interaction.data.type) {
+                case ApplicationCommandType.ChatInput:
+                    return handler(createCommandInteraction(interaction, helpers));
+                case ApplicationCommandType.User:
+                    return handler(createUserContextMenuInteraction(interaction, helpers));
+                case ApplicationCommandType.Message:
+                    return handler(createMessageContextMenuInteraction(interaction, helpers));
+                default:
+                    if (interaction.data.type === ApplicationCommandType.PrimaryEntryPoint) {
+                        return handler(createAppCommandInteraction(interaction, helpers));
+                    }
+                    throw new Error(`[MiniInteraction] Unsupported application command type: ${String(interaction.data.type)}`);
+            }
+        });
+    }
+    async executeComponentHandler(handler, interaction) {
+        return this.runWithResponseLifecycle(interaction, async (helpers) => handler(createMessageComponentInteraction(interaction, helpers)));
+    }
+    async executeModalHandler(handler, interaction) {
+        return this.runWithResponseLifecycle(interaction, async (helpers) => handler(createModalSubmitInteraction(interaction, helpers)));
+    }
+    async runWithResponseLifecycle(interaction, executor) {
+        let ackResponse;
+        const helpers = {
+            canRespond: (interactionId) => (this.responseStates.get(interactionId) ?? "pending") === "pending",
+            trackResponse: (interactionId, _token, state) => {
+                this.responseStates.set(interactionId, state);
+            },
+            onAck: (response) => {
+                ackResponse = response;
+            },
+            sendFollowUp: async (token, response, messageId) => {
+                const responseData = "data" in response ? response.data ?? {} : {};
+                if (messageId === "@original") {
+                    await this.rest.editOriginal(token, responseData);
+                    return;
+                }
+                await this.rest.createFollowup(token, responseData);
+            },
+        };
+        const autoDeferMs = Math.min(2500, this.options.timeoutConfig?.initialResponseTimeout ?? 2500);
+        const autoDeferTimer = this.options.timeoutConfig?.autoDeferSlowOperations === true
+            ? setTimeout(() => {
+                if (!helpers.canRespond(interaction.id))
+                    return;
+                if (this.options.debug || this.options.timeoutConfig?.enableResponseDebugLogging) {
+                    console.warn(`[MiniInteraction] Auto-deferred interaction ${interaction.id} after ${autoDeferMs}ms.`);
+                }
+                ackResponse = {
+                    type: InteractionResponseType.DeferredChannelMessageWithSource,
+                };
+                helpers.trackResponse(interaction.id, interaction.token, "deferred");
+            }, autoDeferMs)
+            : undefined;
+        const timeoutWarningMs = this.options.timeoutConfig?.initialResponseTimeout;
+        const timeoutWarningTimer = this.options.timeoutConfig?.enableTimeoutWarnings && timeoutWarningMs
+            ? setTimeout(() => {
+                if (this.responseStates.get(interaction.id))
+                    return;
+                console.warn(`[MiniInteraction] Interaction ${interaction.id} exceeded ${timeoutWarningMs}ms without a response.`);
+            }, timeoutWarningMs)
+            : undefined;
+        try {
+            const result = await executor(helpers);
+            if (this.options.debug || this.options.timeoutConfig?.enableResponseDebugLogging) {
+                console.debug(`[MiniInteraction] Interaction ${interaction.id} completed with ${result ? "explicit" : "fallback"} response.`);
+            }
+            return result ?? ackResponse;
+        }
+        finally {
+            if (autoDeferTimer)
+                clearTimeout(autoDeferTimer);
+            if (timeoutWarningTimer)
+                clearTimeout(timeoutWarningTimer);
+        }
+    }
+    async loadModules() {
+        if (!this.loadedModulesPromise) {
+            this.loadedModulesPromise = this.discoverModules();
+        }
+        return this.loadedModulesPromise;
+    }
+    async discoverModules() {
+        const commands = this.options.commandsDirectory
+            ? await this.loadDirectory(this.options.commandsDirectory)
+            : [];
+        const components = this.options.componentsDirectory
+            ? await this.loadDirectory(this.options.componentsDirectory)
+            : [];
+        const loaded = {
+            commands: [],
+            components: [],
+            modals: [],
+        };
+        for (const { filePath, value } of commands) {
+            if (this.isInteractionCommand(value)) {
+                loaded.commands.push(value);
+            }
+            else if (this.options.debug) {
+                console.warn(`[MiniInteraction] Ignored non-command module: ${filePath}`);
+            }
+        }
+        for (const { filePath, value } of components) {
+            if (!this.isCustomIdHandler(value)) {
+                if (this.options.debug) {
+                    console.warn(`[MiniInteraction] Ignored non-component module: ${filePath}`);
+                }
+                continue;
+            }
+            if (this.looksLikeModalFile(filePath)) {
+                loaded.modals.push(value);
+            }
+            else {
+                loaded.components.push(value);
+            }
+        }
+        return loaded;
+    }
+    async loadDirectory(directory) {
+        const absoluteDirectory = path.resolve(this.projectRoot, directory);
+        const files = await this.walkFiles(absoluteDirectory);
+        const loaded = await Promise.all(files
+            .filter((filePath) => this.isImportableModule(filePath))
+            .map(async (filePath) => ({
+            filePath,
+            values: this.normalizeModuleExports(await import(pathToFileURL(filePath).href)),
+        })));
+        return loaded.flatMap(({ filePath, values }) => values.map((value) => ({ filePath, value })));
+    }
+    normalizeModuleExports(moduleValue) {
+        const values = [];
+        if ("default" in moduleValue) {
+            values.push(...this.normalizeExportValue(moduleValue.default));
+        }
+        for (const [key, value] of Object.entries(moduleValue)) {
+            if (key === "default")
+                continue;
+            values.push(...this.normalizeExportValue(value));
+        }
+        return values;
+    }
+    normalizeExportValue(value) {
+        if (Array.isArray(value))
+            return value;
+        return [value];
+    }
+    async walkFiles(directory) {
+        const entries = await readdir(directory, { withFileTypes: true });
+        const results = await Promise.all(entries.map(async (entry) => {
+            const resolvedPath = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                return this.walkFiles(resolvedPath);
+            }
+            return [resolvedPath];
+        }));
+        return results.flat();
+    }
+    isImportableModule(filePath) {
+        if (filePath.endsWith(".d.ts"))
+            return false;
+        return /\.(ts|mts|js|mjs|cjs)$/i.test(filePath);
+    }
+    isInteractionCommand(value) {
+        return (typeof value === "object" &&
+            value !== null &&
+            "data" in value &&
+            "handler" in value &&
+            typeof value.handler === "function");
+    }
+    getCommandName(command) {
+        const data = command.data;
+        if (typeof data.toJSON === "function") {
+            return data.toJSON().name;
+        }
+        return data.name;
+    }
+    isCustomIdHandler(value) {
+        return (typeof value === "object" &&
+            value !== null &&
+            "customId" in value &&
+            "handler" in value &&
+            typeof value.customId === "string" &&
+            typeof value.handler === "function");
+    }
+    looksLikeModalFile(filePath) {
+        const normalized = filePath.toLowerCase();
+        return (normalized.includes(`${path.sep}modals${path.sep}`) ||
+            normalized.endsWith(".modal.ts") ||
+            normalized.endsWith(".modal.js") ||
+            normalized.includes("_modal.") ||
+            normalized.includes("-modal."));
+    }
+    async readRawBody(req) {
+        if (typeof req.rawBody === "string")
+            return req.rawBody;
+        if (req.rawBody instanceof Uint8Array) {
+            return Buffer.from(req.rawBody).toString("utf8");
+        }
+        if (typeof req.body === "string")
+            return req.body;
+        if (req.body instanceof Uint8Array) {
+            return Buffer.from(req.body).toString("utf8");
+        }
+        if (req.body && typeof req.body === "object") {
+            return JSON.stringify(req.body);
+        }
+        if (typeof req[Symbol.asyncIterator] === "function") {
+            const chunks = [];
+            for await (const chunk of req) {
+                chunks.push(Buffer.from(chunk));
+            }
+            return Buffer.concat(chunks).toString("utf8");
+        }
+        return "";
+    }
+    getHeader(headers, name) {
+        if (typeof headers.get === "function") {
+            return headers.get(name) ?? undefined;
+        }
+        const recordHeaders = headers;
+        const direct = recordHeaders[name] ??
+            recordHeaders[name.toLowerCase()] ??
+            recordHeaders[name.toUpperCase()];
+        if (Array.isArray(direct))
+            return direct[0];
+        return direct;
+    }
+    sendJson(res, statusCode, body) {
+        if (typeof res.status === "function" && typeof res.json === "function") {
+            const response = res.status(statusCode);
+            response.json?.(body);
+            return;
+        }
+        res.statusCode = statusCode;
+        res.setHeader?.("Content-Type", "application/json; charset=utf-8");
+        res.end(JSON.stringify(body));
+    }
+}
+export const LegacyMiniInteractionAdapter = MiniInteraction;

package/dist/index.d.ts

@@ -4,8 +4,8 @@ export type { AttachmentOptionBuilder, ChannelOptionBuilder, MentionableOptionBu
 export { CommandInteractionOptionResolver, createCommandInteraction, } from "./utils/CommandInteractionOptions.js";
 export { CommandInteraction, MentionableOption, ResolvedUserOption, } from "./utils/CommandInteractionOptions.js";
 export { UserContextMenuInteraction, MessageContextMenuInteraction, AppCommandInteraction, } from "./utils/ContextMenuInteraction.js";
-export type { InteractionCommand, SlashCommandHandler, UserCommandHandler, MessageCommandHandler, AppCommandHandler, CommandHandler, } from "./types/Commands.js";
-export { MessageComponentInteraction, ButtonInteraction, StringSelectInteraction, RoleSelectInteraction, UserSelectInteraction, ChannelSelectInteraction, MentionableSelectInteraction, ResolvedUserOption as ComponentResolvedUserOption, ResolvedMentionableOption as ComponentResolvedMentionableOption, } from "./utils/MessageComponentInteraction.js";
+export type { InteractionCommand, SlashCommandHandler, UserCommandHandler, MessageCommandHandler, AppCommandHandler, CommandHandler, ComponentInteraction, InteractionComponent, InteractionModal, } from "./types/Commands.js";
+export { MessageComponentInteraction, ButtonInteraction, StringSelectInteraction, RoleSelectInteraction, UserSelectInteraction, ChannelSelectInteraction, MentionableSelectInteraction, RadioInteraction, CheckboxInteraction, ResolvedUserOption as ComponentResolvedUserOption, ResolvedMentionableOption as ComponentResolvedMentionableOption, } from "./utils/MessageComponentInteraction.js";
 export { ModalSubmitInteraction } from "./utils/ModalSubmitInteraction.js";
 export { RoleConnectionMetadataTypes } from "./types/RoleConnectionMetadataTypes.js";
 export { ChannelType } from "./types/ChannelType.js";
@@ -14,7 +14,7 @@ export { ButtonStyle } from "./types/ButtonStyle.js";
 export { SeparatorSpacingSize } from "./types/SeparatorSpacingSize.js";
 export { TextInputStyle } from "discord-api-types/v10";
 export { MiniPermFlags } from "./types/PermissionFlags.js";
-export type { ActionRowComponent, MessageActionRowComponent, } from "./types/ComponentTypes.js";
+export type { ActionRowComponent, MessageActionRowComponent, InteractionComponentData, } from "./types/ComponentTypes.js";
 export * from "./builders/index.js";
 export { MiniDataBuilder } from "./database/MiniDataBuilder.js";
 export type { DataField } from "./database/MiniDataBuilder.js";
@@ -30,6 +30,10 @@ export { InteractionContext } from "./core/interactions/InteractionContext.js";
 export type { InteractionContextOptions } from "./core/interactions/InteractionContext.js";
 export { verifyAndParseInteraction } from "./core/interactions/InteractionVerifier.js";
 export { InteractionRouter } from "./router/InteractionRouter.js";
+export { MiniInteraction, LegacyMiniInteractionAdapter, } from "./compat/MiniInteraction.js";
+export type { MiniInteractionOptions } from "./compat/MiniInteraction.js";
 export type { APIRadioComponent, APIRadioOption } from "./types/radio.js";
 export { RADIO_COMPONENT_TYPE } from "./types/radio.js";
+export type { APICheckboxComponent, APICheckboxOption } from "./types/checkbox.js";
+export { CHECKBOX_COMPONENT_TYPE } from "./types/checkbox.js";
 export { ValidationError } from "./types/validation.js";

package/dist/index.js

@@ -3,7 +3,7 @@ export { UserCommandBuilder, MessageCommandBuilder, AppCommandBuilder, } from ".
 export { CommandInteractionOptionResolver, createCommandInteraction, } from "./utils/CommandInteractionOptions.js";
 export { CommandInteraction, MentionableOption, ResolvedUserOption, } from "./utils/CommandInteractionOptions.js";
 export { UserContextMenuInteraction, MessageContextMenuInteraction, AppCommandInteraction, } from "./utils/ContextMenuInteraction.js";
-export { MessageComponentInteraction, ButtonInteraction, StringSelectInteraction, RoleSelectInteraction, UserSelectInteraction, ChannelSelectInteraction, MentionableSelectInteraction, ResolvedUserOption as ComponentResolvedUserOption, ResolvedMentionableOption as ComponentResolvedMentionableOption, } from "./utils/MessageComponentInteraction.js";
+export { MessageComponentInteraction, ButtonInteraction, StringSelectInteraction, RoleSelectInteraction, UserSelectInteraction, ChannelSelectInteraction, MentionableSelectInteraction, RadioInteraction, CheckboxInteraction, ResolvedUserOption as ComponentResolvedUserOption, ResolvedMentionableOption as ComponentResolvedMentionableOption, } from "./utils/MessageComponentInteraction.js";
 export { ModalSubmitInteraction } from "./utils/ModalSubmitInteraction.js";
 export { RoleConnectionMetadataTypes } from "./types/RoleConnectionMetadataTypes.js";
 export { ChannelType } from "./types/ChannelType.js";
@@ -23,5 +23,7 @@ export { DiscordRestClient } from "./core/http/DiscordRestClient.js";
 export { InteractionContext } from "./core/interactions/InteractionContext.js";
 export { verifyAndParseInteraction } from "./core/interactions/InteractionVerifier.js";
 export { InteractionRouter } from "./router/InteractionRouter.js";
+export { MiniInteraction, LegacyMiniInteractionAdapter, } from "./compat/MiniInteraction.js";
 export { RADIO_COMPONENT_TYPE } from "./types/radio.js";
+export { CHECKBOX_COMPONENT_TYPE } from "./types/checkbox.js";
 export { ValidationError } from "./types/validation.js";

package/dist/types/Commands.d.ts

@@ -1,6 +1,8 @@
 import type { APIInteractionResponse, RESTPostAPIChatInputApplicationCommandsJSONBody, RESTPostAPIContextMenuApplicationCommandsJSONBody, RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody } from "discord-api-types/v10";
 import type { CommandInteraction } from "../utils/CommandInteractionOptions.js";
 import type { UserContextMenuInteraction, MessageContextMenuInteraction, AppCommandInteraction } from "../utils/ContextMenuInteraction.js";
+import type { ButtonInteraction, StringSelectInteraction, RoleSelectInteraction, UserSelectInteraction, ChannelSelectInteraction, MentionableSelectInteraction, RadioInteraction, CheckboxInteraction } from "../utils/MessageComponentInteraction.js";
+import type { ModalSubmitInteraction } from "../utils/ModalSubmitInteraction.js";
 import type { JSONEncodable } from "../builders/shared.js";
 import type { CommandBuilder } from "../commands/CommandBuilder.js";
 import type { MessageCommandBuilder, UserCommandBuilder, AppCommandBuilder } from "../commands/ContextMenuCommandBuilder.js";
@@ -19,5 +21,17 @@ export type InteractionCommand = {
     data: RESTPostAPIChatInputApplicationCommandsJSONBody | RESTPostAPIContextMenuApplicationCommandsJSONBody | RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody | CommandBuilder | UserCommandBuilder | MessageCommandBuilder | AppCommandBuilder | JSONEncodable<RESTPostAPIChatInputApplicationCommandsJSONBody | RESTPostAPIContextMenuApplicationCommandsJSONBody | RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody>;
     handler: CommandHandler;
 };
+/** Handler for any message component interaction */
+export type ComponentInteraction = ButtonInteraction | StringSelectInteraction | RoleSelectInteraction | UserSelectInteraction | ChannelSelectInteraction | MentionableSelectInteraction | RadioInteraction | CheckboxInteraction;
+/** Structure for a standalone component handler */
+export type InteractionComponent = {
+    customId: string;
+    handler: (interaction: ComponentInteraction) => Promise<APIInteractionResponse | void> | APIInteractionResponse | void;
+};
+/** Structure for a standalone modal handler */
+export type InteractionModal = {
+    customId: string;
+    handler: (interaction: ModalSubmitInteraction) => Promise<APIInteractionResponse | void> | APIInteractionResponse | void;
+};
 /** Map of command names to their registered MiniInteraction command definitions. */
 export type InteractionCommandsMap = Map<string, InteractionCommand>;

package/dist/types/ComponentTypes.d.ts

@@ -1,5 +1,19 @@
-import type { APIComponentInActionRow, APIComponentInMessageActionRow } from "discord-api-types/v10";
+import type { APIComponentInActionRow, APIComponentInMessageActionRow, APIModalInteractionResponseCallbackComponent } from "discord-api-types/v10";
+import type { APIRadioComponent } from "./radio.js";
+import type { APICheckboxComponent } from "./checkbox.js";
 /** Defines a component structure for use in ActionRow builders. */
-export type ActionRowComponent = APIComponentInActionRow;
+export type ActionRowComponent = APIComponentInActionRow | APIRadioComponent | APICheckboxComponent;
 /** Defines a message component structure for use in message builders. */
-export type MessageActionRowComponent = APIComponentInMessageActionRow;
+export type MessageActionRowComponent = APIComponentInMessageActionRow | APIRadioComponent | APICheckboxComponent;
+/** Structure for an action row containing mini-interaction components. */
+export interface MiniActionRow<T extends ActionRowComponent = ActionRowComponent> {
+    type: 1;
+    components: T[];
+}
+/** Structure for a message action row containing mini-interaction components. */
+export interface MessageMiniActionRow<T extends MessageActionRowComponent = MessageActionRowComponent> {
+    type: 1;
+    components: T[];
+}
+/** Generic type for any supported interaction component data. */
+export type InteractionComponentData = MessageActionRowComponent | APIModalInteractionResponseCallbackComponent;

package/dist/types/checkbox.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Discord API support for checkbox components may lag behind discord-api-types releases.
+ * These local contracts are runtime-validated and serialized as raw component payloads.
+ */
+export declare const CHECKBOX_COMPONENT_TYPE: 2002;
+export type APICheckboxOption = {
+    label: string;
+    value: string;
+    description?: string;
+    emoji?: {
+        id?: string;
+        name?: string;
+        animated?: boolean;
+    };
+    default?: boolean;
+};
+export type APICheckboxComponent = {
+    type: typeof CHECKBOX_COMPONENT_TYPE;
+    custom_id: string;
+    disabled?: boolean;
+    required?: boolean;
+    options: APICheckboxOption[];
+};

package/dist/types/checkbox.js

@@ -0,0 +1,5 @@
+/**
+ * Discord API support for checkbox components may lag behind discord-api-types releases.
+ * These local contracts are runtime-validated and serialized as raw component payloads.
+ */
+export const CHECKBOX_COMPONENT_TYPE = 2002;

package/dist/utils/MessageComponentInteraction.d.ts

@@ -138,6 +138,44 @@ export interface MentionableSelectInteraction extends Omit<APIMessageComponentIn
     trackResponse?: (interactionId: string, token: string, state: 'responded' | 'deferred') => void;
 }
 export declare const MentionableSelectInteraction: {};
+/**
+ * Radio interaction with helper methods.
+ */
+export interface RadioInteraction extends Omit<APIMessageComponentInteraction, "data"> {
+    data: APIMessageStringSelectInteractionData;
+    values: string[];
+    getStringValues: () => string[];
+    getResponse: () => APIInteractionResponse | null;
+    reply: (data: InteractionMessageData) => Promise<APIInteractionResponseChannelMessageWithSource>;
+    deferReply: (options?: DeferReplyOptions) => APIInteractionResponseDeferredChannelMessageWithSource;
+    update: (data?: InteractionMessageData) => Promise<APIInteractionResponseUpdateMessage>;
+    deferUpdate: () => APIInteractionResponseDeferredMessageUpdate;
+    showModal: (data: APIModalInteractionResponseCallbackData | {
+        toJSON(): APIModalInteractionResponseCallbackData;
+    }) => APIModalInteractionResponse;
+    canRespond?: (interactionId: string) => boolean;
+    trackResponse?: (interactionId: string, token: string, state: 'responded' | 'deferred') => void;
+}
+export declare const RadioInteraction: {};
+/**
+ * Checkbox interaction with helper methods.
+ */
+export interface CheckboxInteraction extends Omit<APIMessageComponentInteraction, "data"> {
+    data: APIMessageStringSelectInteractionData;
+    values: string[];
+    getStringValues: () => string[];
+    getResponse: () => APIInteractionResponse | null;
+    reply: (data: InteractionMessageData) => Promise<APIInteractionResponseChannelMessageWithSource>;
+    deferReply: (options?: DeferReplyOptions) => APIInteractionResponseDeferredChannelMessageWithSource;
+    update: (data?: InteractionMessageData) => Promise<APIInteractionResponseUpdateMessage>;
+    deferUpdate: () => APIInteractionResponseDeferredMessageUpdate;
+    showModal: (data: APIModalInteractionResponseCallbackData | {
+        toJSON(): APIModalInteractionResponseCallbackData;
+    }) => APIModalInteractionResponse;
+    canRespond?: (interactionId: string) => boolean;
+    trackResponse?: (interactionId: string, token: string, state: 'responded' | 'deferred') => void;
+}
+export declare const CheckboxInteraction: {};
 /**
  * Represents a component interaction augmented with helper response methods.
  *

package/dist/utils/MessageComponentInteraction.js

@@ -8,6 +8,8 @@ export const RoleSelectInteraction = {};
 export const UserSelectInteraction = {};
 export const ChannelSelectInteraction = {};
 export const MentionableSelectInteraction = {};
+export const RadioInteraction = {};
+export const CheckboxInteraction = {};
 export const MessageComponentInteraction = {};
 /**
  * Wraps a raw component interaction with helper methods mirroring Discord's expected responses.

package/dist/utils/interactionMessageHelpers.d.ts

@@ -1,11 +1,12 @@
 import type { APIInteractionResponseCallbackData, MessageFlags } from "discord-api-types/v10";
-import type { APIActionRowComponent, APIComponentInMessageActionRow, APIContainerComponent } from "discord-api-types/v10";
+import type { APIContainerComponent } from "discord-api-types/v10";
 import type { JSONEncodable } from "../builders/shared.js";
 import { InteractionFlags } from "../types/InteractionFlags.js";
+import type { MessageMiniActionRow } from "../types/ComponentTypes.js";
 /** Union of helper flag enums and raw Discord message flags. */
 export type MessageFlagLike = MessageFlags | InteractionFlags;
 /** Top-level components allowed in messages (ActionRows or Containers) */
-export type TopLevelComponent = APIActionRowComponent<APIComponentInMessageActionRow> | APIContainerComponent;
+export type TopLevelComponent = MessageMiniActionRow | APIContainerComponent;
 /** Message payload accepted by helper reply/edit functions. */
 export type InteractionMessageData = {
     content?: string;

package/dist/utils/interactionMessageHelpers.js

@@ -10,6 +10,8 @@ const COMPONENTS_V2_TYPES = new Set([
     ComponentType.Thumbnail,
     18, // Label
     19, // FileUpload
+    2001, // Radio
+    2002, // Checkbox
 ]);
 /**
  * Normalises helper flag enums into the raw Discord `MessageFlags` bitfield.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minesa-org/mini-interaction",
-  "version": "0.4.1",
+  "version": "0.4.4",
   "description": "Mini interaction, connecting your app with Discord via HTTP-interaction (Vercel support).",
   "type": "module",
   "main": "dist/index.js",