@minesa-org/mini-interaction 0.3.13 → 0.4.0

package/dist/builders/ModalRoleSelectMenuBuilder.d.ts

@@ -1,6 +1,5 @@
-import { SelectMenuDefaultValueType, type APIRoleSelectComponent, type APISelectMenuDefaultValue } from "discord-api-types/v10";
-import type { JSONEncodable } from "./shared.js";
-/** Shape describing initial modal role select menu data accepted by the builder. */
+import { SelectMenuDefaultValueType, type APIRoleSelectComponent, type APISelectMenuDefaultValue } from 'discord-api-types/v10';
+import type { JSONEncodable } from './shared.js';
 export type ModalRoleSelectMenuBuilderData = {
     customId?: string;
     placeholder?: string;
@@ -10,43 +9,15 @@ export type ModalRoleSelectMenuBuilderData = {
     required?: boolean;
     defaultValues?: APISelectMenuDefaultValue<SelectMenuDefaultValueType.Role>[];
 };
-/** Builder for Discord role select menu components in modals. */
 export declare class ModalRoleSelectMenuBuilder implements JSONEncodable<APIRoleSelectComponent> {
-    private data;
-    /**
-     * Creates a new modal role select menu builder with optional seed data.
-     */
+    private readonly data;
     constructor(data?: ModalRoleSelectMenuBuilderData);
-    /**
-     * Sets the unique custom identifier for the select menu interaction.
-     */
     setCustomId(customId: string): this;
-    /**
-     * Sets or clears the placeholder text displayed when no role is selected.
-     */
-    setPlaceholder(placeholder: string | null | undefined): this;
-    /**
-     * Sets the minimum number of roles that must be selected.
-     */
-    setMinValues(minValues: number | null | undefined): this;
-    /**
-     * Sets the maximum number of roles that can be selected.
-     */
-    setMaxValues(maxValues: number | null | undefined): this;
-    /**
-     * Toggles whether the select menu is disabled.
-     */
+    setPlaceholder(placeholder?: string): this;
+    setMinValues(minValues?: number): this;
+    setMaxValues(maxValues?: number): this;
     setDisabled(disabled: boolean): this;
-    /**
-     * Marks the select menu as required in the modal.
-     */
     setRequired(required: boolean): this;
-    /**
-     * Replaces the default role selections displayed when the menu renders.
-     */
     setDefaultValues(defaultValues: Iterable<APISelectMenuDefaultValue<SelectMenuDefaultValueType.Role>>): this;
-    /**
-     * Serialises the builder into an API compatible role select menu payload.
-     */
     toJSON(): APIRoleSelectComponent;
 }

package/dist/builders/ModalRoleSelectMenuBuilder.js

@@ -1,98 +1,29 @@
-import { ComponentType, SelectMenuDefaultValueType, } from "discord-api-types/v10";
-/** Builder for Discord role select menu components in modals. */
+import { ComponentType, SelectMenuDefaultValueType } from 'discord-api-types/v10';
+import { assertDefined, assertRange, assertStringLength, ValidationError } from '../types/validation.js';
 export class ModalRoleSelectMenuBuilder {
     data;
-    /**
-     * Creates a new modal role select menu builder with optional seed data.
-     */
-    constructor(data = {}) {
-        this.data = {
-            customId: data.customId,
-            placeholder: data.placeholder,
-            minValues: data.minValues,
-            maxValues: data.maxValues,
-            disabled: data.disabled,
-            required: data.required,
-            defaultValues: data.defaultValues
-                ? data.defaultValues.map((value) => ({
-                    ...value,
-                    type: SelectMenuDefaultValueType.Role,
-                }))
-                : undefined,
-        };
-    }
-    /**
-     * Sets the unique custom identifier for the select menu interaction.
-     */
-    setCustomId(customId) {
-        this.data.customId = customId;
-        return this;
-    }
-    /**
-     * Sets or clears the placeholder text displayed when no role is selected.
-     */
-    setPlaceholder(placeholder) {
-        this.data.placeholder = placeholder ?? undefined;
-        return this;
-    }
-    /**
-     * Sets the minimum number of roles that must be selected.
-     */
-    setMinValues(minValues) {
-        this.data.minValues = minValues ?? undefined;
-        return this;
-    }
-    /**
-     * Sets the maximum number of roles that can be selected.
-     */
-    setMaxValues(maxValues) {
-        this.data.maxValues = maxValues ?? undefined;
-        return this;
-    }
-    /**
-     * Toggles whether the select menu is disabled.
-     */
-    setDisabled(disabled) {
-        this.data.disabled = disabled;
-        return this;
-    }
-    /**
-     * Marks the select menu as required in the modal.
-     */
-    setRequired(required) {
-        this.data.required = required;
-        return this;
-    }
-    /**
-     * Replaces the default role selections displayed when the menu renders.
-     */
+    constructor(data = {}) { this.data = { ...data }; }
+    setCustomId(customId) { this.data.customId = customId; return this; }
+    setPlaceholder(placeholder) { this.data.placeholder = placeholder; return this; }
+    setMinValues(minValues) { this.data.minValues = minValues; return this; }
+    setMaxValues(maxValues) { this.data.maxValues = maxValues; return this; }
+    setDisabled(disabled) { this.data.disabled = disabled; return this; }
+    setRequired(required) { this.data.required = required; return this; }
     setDefaultValues(defaultValues) {
-        this.data.defaultValues = Array.from(defaultValues, (value) => ({
-            ...value,
-            type: SelectMenuDefaultValueType.Role,
-        }));
+        this.data.defaultValues = Array.from(defaultValues, (v) => ({ ...v, type: SelectMenuDefaultValueType.Role }));
         return this;
     }
-    /**
-     * Serialises the builder into an API compatible role select menu payload.
-     */
     toJSON() {
-        const { customId } = this.data;
-        if (!customId) {
-            throw new Error("[ModalRoleSelectMenuBuilder] custom id is required.");
-        }
-        return {
-            type: ComponentType.RoleSelect,
-            custom_id: customId,
-            placeholder: this.data.placeholder,
-            min_values: this.data.minValues,
-            max_values: this.data.maxValues,
-            disabled: this.data.disabled,
-            required: this.data.required,
-            default_values: this.data.defaultValues?.map((value) => ({
-                ...value,
-                type: SelectMenuDefaultValueType.Role,
-            })),
-        };
+        const customId = assertDefined('ModalRoleSelectMenuBuilder', 'custom_id', this.data.customId);
+        assertStringLength('ModalRoleSelectMenuBuilder', 'custom_id', customId, 1, 100);
+        if (this.data.placeholder)
+            assertStringLength('ModalRoleSelectMenuBuilder', 'placeholder', this.data.placeholder, 1, 150);
+        if (this.data.minValues !== undefined)
+            assertRange('ModalRoleSelectMenuBuilder', 'min_values', this.data.minValues, 0, 25);
+        if (this.data.maxValues !== undefined)
+            assertRange('ModalRoleSelectMenuBuilder', 'max_values', this.data.maxValues, 1, 25);
+        if (this.data.minValues !== undefined && this.data.maxValues !== undefined && this.data.minValues > this.data.maxValues)
+            throw new ValidationError('ModalRoleSelectMenuBuilder', 'min_values', 'cannot exceed max_values');
+        return { type: ComponentType.RoleSelect, custom_id: customId, placeholder: this.data.placeholder, min_values: this.data.minValues, max_values: this.data.maxValues, disabled: this.data.disabled, required: this.data.required, default_values: this.data.defaultValues };
     }
 }

package/dist/builders/RadioBuilder.d.ts

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

package/dist/builders/RadioBuilder.js

@@ -0,0 +1,29 @@
+import { RADIO_COMPONENT_TYPE } from '../types/radio.js';
+import { assertDefined, assertStringLength, ValidationError } from '../types/validation.js';
+export class RadioBuilder {
+    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('RadioBuilder', 'custom_id', this.data.customId);
+        assertStringLength('RadioBuilder', 'custom_id', customId, 1, 100);
+        const options = [...(this.data.options ?? [])];
+        if (options.length === 0 || options.length > 25)
+            throw new ValidationError('RadioBuilder', 'options', 'must contain 1-25 options');
+        let defaults = 0;
+        for (const [index, option] of options.entries()) {
+            assertStringLength('RadioBuilder', `options[${index}].label`, option.label, 1, 100);
+            assertStringLength('RadioBuilder', `options[${index}].value`, option.value, 1, 100);
+            if (option.description)
+                assertStringLength('RadioBuilder', `options[${index}].description`, option.description, 1, 100);
+            if (option.default)
+                defaults += 1;
+        }
+        if (defaults > 1)
+            throw new ValidationError('RadioBuilder', 'options.default', 'radio supports only one default option');
+        return { type: RADIO_COMPONENT_TYPE, custom_id: customId, disabled: this.data.disabled, required: this.data.required, options };
+    }
+}

package/dist/builders/TextInputBuilder.d.ts

@@ -1,6 +1,5 @@
-import { TextInputStyle, type APITextInputComponent } from "discord-api-types/v10";
-import type { JSONEncodable } from "./shared.js";
-/** Shape describing initial text input data accepted by the builder. */
+import { TextInputStyle, type APITextInputComponent } from 'discord-api-types/v10';
+import { type JSONEncodable } from './shared.js';
 export type TextInputBuilderData = {
     customId?: string;
     style?: TextInputStyle;
@@ -10,43 +9,15 @@ export type TextInputBuilderData = {
     value?: string;
     placeholder?: string;
 };
-/** Builder for Discord text input components used in modals. */
 export declare class TextInputBuilder implements JSONEncodable<APITextInputComponent> {
-    private data;
-    /**
-     * Creates a new text input builder with optional seed data.
-     */
+    private readonly data;
     constructor(data?: TextInputBuilderData);
-    /**
-     * Sets the custom identifier for this text input.
-     */
     setCustomId(customId: string): this;
-    /**
-     * Sets the style of the text input (Short or Paragraph).
-     */
     setStyle(style: TextInputStyle): this;
-    /**
-     * Sets the minimum length of the input text.
-     */
     setMinLength(minLength: number): this;
-    /**
-     * Sets the maximum length of the input text.
-     */
     setMaxLength(maxLength: number): this;
-    /**
-     * Sets whether this text input is required.
-     */
     setRequired(required: boolean): this;
-    /**
-     * Sets the pre-filled value for this text input.
-     */
     setValue(value: string): this;
-    /**
-     * Sets the placeholder text shown when the input is empty.
-     */
     setPlaceholder(placeholder: string): this;
-    /**
-     * Serialises the builder into an API compatible text input payload.
-     */
     toJSON(): APITextInputComponent;
 }

package/dist/builders/TextInputBuilder.js

@@ -1,88 +1,26 @@
-import { ComponentType, TextInputStyle, } from "discord-api-types/v10";
-/** Builder for Discord text input components used in modals. */
+import { ComponentType, TextInputStyle } from 'discord-api-types/v10';
+import { assertDefined, assertRange, assertStringLength } from '../types/validation.js';
 export class TextInputBuilder {
     data;
-    /**
-     * Creates a new text input builder with optional seed data.
-     */
-    constructor(data = {}) {
-        this.data = {
-            customId: data.customId,
-            style: data.style ?? TextInputStyle.Short,
-            minLength: data.minLength,
-            maxLength: data.maxLength,
-            required: data.required,
-            value: data.value,
-            placeholder: data.placeholder,
-        };
-    }
-    /**
-     * Sets the custom identifier for this text input.
-     */
-    setCustomId(customId) {
-        this.data.customId = customId;
-        return this;
-    }
-    /**
-     * Sets the style of the text input (Short or Paragraph).
-     */
-    setStyle(style) {
-        this.data.style = style;
-        return this;
-    }
-    /**
-     * Sets the minimum length of the input text.
-     */
-    setMinLength(minLength) {
-        this.data.minLength = minLength;
-        return this;
-    }
-    /**
-     * Sets the maximum length of the input text.
-     */
-    setMaxLength(maxLength) {
-        this.data.maxLength = maxLength;
-        return this;
-    }
-    /**
-     * Sets whether this text input is required.
-     */
-    setRequired(required) {
-        this.data.required = required;
-        return this;
-    }
-    /**
-     * Sets the pre-filled value for this text input.
-     */
-    setValue(value) {
-        this.data.value = value;
-        return this;
-    }
-    /**
-     * Sets the placeholder text shown when the input is empty.
-     */
-    setPlaceholder(placeholder) {
-        this.data.placeholder = placeholder;
-        return this;
-    }
-    /**
-     * Serialises the builder into an API compatible text input payload.
-     */
+    constructor(data = {}) { this.data = { style: TextInputStyle.Short, ...data }; }
+    setCustomId(customId) { this.data.customId = customId; return this; }
+    setStyle(style) { this.data.style = style; return this; }
+    setMinLength(minLength) { this.data.minLength = minLength; return this; }
+    setMaxLength(maxLength) { this.data.maxLength = maxLength; return this; }
+    setRequired(required) { this.data.required = required; return this; }
+    setValue(value) { this.data.value = value; return this; }
+    setPlaceholder(placeholder) { this.data.placeholder = placeholder; return this; }
     toJSON() {
-        if (!this.data.customId) {
-            throw new Error("[TextInputBuilder] custom_id is required.");
-        }
-        // Note: label is optional when used inside a LabelComponent
-        // but required when used standalone in an ActionRow
-        return {
-            type: ComponentType.TextInput,
-            custom_id: this.data.customId,
-            style: this.data.style ?? TextInputStyle.Short,
-            min_length: this.data.minLength,
-            max_length: this.data.maxLength,
-            required: this.data.required,
-            value: this.data.value,
-            placeholder: this.data.placeholder,
-        };
+        const customId = assertDefined('TextInputBuilder', 'custom_id', this.data.customId);
+        assertStringLength('TextInputBuilder', 'custom_id', customId, 1, 100);
+        if (this.data.minLength !== undefined)
+            assertRange('TextInputBuilder', 'min_length', this.data.minLength, 0, 4000);
+        if (this.data.maxLength !== undefined)
+            assertRange('TextInputBuilder', 'max_length', this.data.maxLength, 1, 4000);
+        if (this.data.placeholder)
+            assertStringLength('TextInputBuilder', 'placeholder', this.data.placeholder, 1, 100);
+        if (this.data.value)
+            assertStringLength('TextInputBuilder', 'value', this.data.value, 0, 4000);
+        return { type: ComponentType.TextInput, custom_id: customId, style: this.data.style ?? TextInputStyle.Short, min_length: this.data.minLength, max_length: this.data.maxLength, required: this.data.required, value: this.data.value, placeholder: this.data.placeholder };
     }
 }

package/dist/builders/__tests__/builders.test.d.ts

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

package/dist/builders/__tests__/builders.test.js

@@ -0,0 +1,31 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { LabelBuilder } from '../LabelBuilder.js';
+import { TextInputBuilder } from '../TextInputBuilder.js';
+import { FileUploadBuilder } from '../FileUploadBuilder.js';
+import { ModalBuilder } from '../ModalBuilder.js';
+import { ModalRoleSelectMenuBuilder } from '../ModalRoleSelectMenuBuilder.js';
+import { RadioBuilder } from '../RadioBuilder.js';
+import { ComponentType, TextInputStyle } from 'discord-api-types/v10';
+test('TextInputBuilder validation and snapshot', () => {
+    const json = new TextInputBuilder().setCustomId('name').setStyle(TextInputStyle.Short).setMinLength(1).setMaxLength(20).toJSON();
+    assert.equal(json.type, ComponentType.TextInput);
+    assert.match(JSON.stringify(json), /"custom_id":"name"/);
+});
+test('LabelBuilder throws descriptive errors', () => {
+    assert.throws(() => new LabelBuilder().toJSON(), /\[LabelBuilder\] label/);
+});
+test('FileUploadBuilder min > max fails', () => {
+    assert.throws(() => new FileUploadBuilder().setCustomId('upload').setMinValues(3).setMaxValues(1).toJSON(), /min_values/);
+});
+test('ModalBuilder validates nesting', () => {
+    const text = new TextInputBuilder().setCustomId('x').toJSON();
+    assert.throws(() => new ModalBuilder().setCustomId('id').setTitle('t').addComponents(text).toJSON(), /invalid modal top-level/);
+});
+test('ModalRoleSelectMenuBuilder serializes', () => {
+    const json = new ModalRoleSelectMenuBuilder().setCustomId('role').setMinValues(1).setMaxValues(1).toJSON();
+    assert.equal(json.type, ComponentType.RoleSelect);
+});
+test('RadioBuilder single default rule', () => {
+    assert.throws(() => new RadioBuilder().setCustomId('r').addOptions({ label: 'A', value: 'a', default: true }, { label: 'B', value: 'b', default: true }).toJSON(), /only one default/);
+});

package/dist/builders/index.d.ts

@@ -36,3 +36,5 @@ export type { EmbedBuilderData } from "./EmbedBuilder.js";
 export { ContainerBuilder, SectionBuilder, TextDisplayBuilder, SeparatorBuilder, GalleryBuilder, GalleryItemBuilder, ThumbnailBuilder, } from "./MiniContainerBuilder.js";
 export type { ContainerBuilderData, SectionBuilderData, TextDisplayBuilderData, SeparatorBuilderData, GalleryBuilderData, GalleryItemBuilderData, ThumbnailBuilderData, MiniContainerComponent, MiniSectionComponent, MiniTextDisplayComponent, MiniSeparatorComponent, MiniGalleryComponent, MiniGalleryItemComponent, MiniThumbnailComponent, MiniContentComponent, MiniSectionAccessoryComponent, } from "./MiniContainerBuilder.js";
 export type { JSONEncodable } from "./shared.js";
+export { RadioBuilder } from "./RadioBuilder.js";
+export type { RadioBuilderData } from "./RadioBuilder.js";

package/dist/builders/index.js

@@ -17,3 +17,4 @@ export { FileUploadBuilder } from "./FileUploadBuilder.js";
 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";

package/dist/compat/LegacyMiniInteractionAdapter.d.ts

@@ -0,0 +1,19 @@
+import type { APIInteractionResponse } from 'discord-api-types/v10';
+import { DiscordRestClient } from '../core/http/DiscordRestClient.js';
+import { InteractionRouter } from '../router/InteractionRouter.js';
+export type LegacyAdapterOptions = {
+    publicKey: string;
+    applicationId: string;
+    token: string;
+};
+export declare class LegacyMiniInteractionAdapter {
+    private readonly options;
+    readonly router: InteractionRouter;
+    readonly rest: DiscordRestClient;
+    constructor(options: LegacyAdapterOptions);
+    handleRequest(input: {
+        body: string;
+        signature: string;
+        timestamp: string;
+    }): Promise<APIInteractionResponse>;
+}

package/dist/compat/LegacyMiniInteractionAdapter.js

@@ -0,0 +1,23 @@
+import { InteractionType } from 'discord-api-types/v10';
+import { DiscordRestClient } from '../core/http/DiscordRestClient.js';
+import { InteractionContext } from '../core/interactions/InteractionContext.js';
+import { verifyAndParseInteraction } from '../core/interactions/InteractionVerifier.js';
+import { InteractionRouter } from '../router/InteractionRouter.js';
+export class LegacyMiniInteractionAdapter {
+    options;
+    router = new InteractionRouter();
+    rest;
+    constructor(options) {
+        this.options = options;
+        this.rest = new DiscordRestClient({ applicationId: options.applicationId, token: options.token });
+    }
+    async handleRequest(input) {
+        const interaction = await verifyAndParseInteraction({ ...input, publicKey: this.options.publicKey });
+        if (interaction.type === InteractionType.Ping) {
+            return { type: 1 };
+        }
+        const ctx = new InteractionContext({ interaction, rest: this.rest, autoAck: { enabled: true } });
+        const response = await this.router.dispatch(interaction, ctx);
+        return response ?? ctx.deferReply();
+    }
+}

package/dist/core/http/DiscordRestClient.d.ts

@@ -0,0 +1,19 @@
+type FetchLike = typeof fetch;
+export type DiscordRestClientOptions = {
+    token: string;
+    applicationId: string;
+    apiBaseUrl?: string;
+    maxRetries?: number;
+    fetchImplementation?: FetchLike;
+};
+export declare class DiscordRestClient {
+    private readonly options;
+    private readonly fetchImpl;
+    private readonly baseUrl;
+    private readonly maxRetries;
+    constructor(options: DiscordRestClientOptions);
+    request<T>(path: string, init?: RequestInit): Promise<T>;
+    createFollowup(interactionToken: string, body: unknown): Promise<unknown>;
+    editOriginal(interactionToken: string, body: unknown): Promise<unknown>;
+}
+export {};

package/dist/core/http/DiscordRestClient.js

@@ -0,0 +1,55 @@
+import { setTimeout as sleep } from 'node:timers/promises';
+export class DiscordRestClient {
+    options;
+    fetchImpl;
+    baseUrl;
+    maxRetries;
+    constructor(options) {
+        this.options = options;
+        this.fetchImpl = options.fetchImplementation ?? fetch;
+        this.baseUrl = options.apiBaseUrl ?? 'https://discord.com/api/v10';
+        this.maxRetries = options.maxRetries ?? 3;
+    }
+    async request(path, init = {}) {
+        let lastError;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt += 1) {
+            const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+                ...init,
+                headers: {
+                    Authorization: `Bot ${this.options.token}`,
+                    'Content-Type': 'application/json',
+                    ...(init.headers ?? {}),
+                },
+            });
+            if (response.status === 429) {
+                const retryAfter = Number(response.headers.get('retry-after') ?? '1');
+                await sleep(Math.ceil(retryAfter * 1000));
+                continue;
+            }
+            if (response.ok) {
+                if (response.status === 204)
+                    return undefined;
+                return (await response.json());
+            }
+            if (response.status >= 500 && attempt < this.maxRetries) {
+                await sleep(150 * (attempt + 1));
+                continue;
+            }
+            lastError = new Error(`[DiscordRestClient] ${init.method ?? 'GET'} ${path} failed: ${response.status}`);
+            break;
+        }
+        throw lastError instanceof Error ? lastError : new Error('[DiscordRestClient] unknown request failure');
+    }
+    createFollowup(interactionToken, body) {
+        return this.request(`/webhooks/${this.options.applicationId}/${interactionToken}`, {
+            method: 'POST',
+            body: JSON.stringify(body),
+        });
+    }
+    editOriginal(interactionToken, body) {
+        return this.request(`/webhooks/${this.options.applicationId}/${interactionToken}/messages/@original`, {
+            method: 'PATCH',
+            body: JSON.stringify(body),
+        });
+    }
+}

package/dist/core/interactions/InteractionContext.d.ts

@@ -0,0 +1,25 @@
+import type { APIInteractionResponse, APIInteractionResponseCallbackData, APIModalInteractionResponseCallbackData } from 'discord-api-types/v10';
+import type { ParsedInteraction } from '../../types/discord.js';
+import { DiscordRestClient } from '../http/DiscordRestClient.js';
+export type InteractionContextOptions = {
+    interaction: ParsedInteraction;
+    rest: DiscordRestClient;
+    autoAck?: {
+        enabled: boolean;
+        delayMs?: number;
+    };
+    onDiagnostic?: (message: string) => void;
+};
+export declare class InteractionContext {
+    private readonly options;
+    private responded;
+    private autoAckTimer?;
+    constructor(options: InteractionContextOptions);
+    reply(data: APIInteractionResponseCallbackData): APIInteractionResponse;
+    deferReply(ephemeral?: boolean): APIInteractionResponse;
+    showModal(data: APIModalInteractionResponseCallbackData): APIInteractionResponse;
+    editReply(body: unknown): Promise<unknown>;
+    followUp(body: unknown): Promise<unknown>;
+    get hasResponded(): boolean;
+    private clearAutoAck;
+}

package/dist/core/interactions/InteractionContext.js

@@ -0,0 +1,44 @@
+export class InteractionContext {
+    options;
+    responded = false;
+    autoAckTimer;
+    constructor(options) {
+        this.options = options;
+        if (options.autoAck?.enabled) {
+            const delay = options.autoAck.delayMs ?? 2000;
+            this.autoAckTimer = setTimeout(() => {
+                if (!this.responded) {
+                    options.onDiagnostic?.(`[InteractionContext] auto-ack triggered for ${this.options.interaction.id}`);
+                }
+            }, delay);
+        }
+    }
+    reply(data) {
+        this.responded = true;
+        this.clearAutoAck();
+        return { type: 4, data };
+    }
+    deferReply(ephemeral = false) {
+        this.responded = true;
+        this.clearAutoAck();
+        return { type: 5, data: ephemeral ? { flags: 64 } : undefined };
+    }
+    showModal(data) {
+        this.responded = true;
+        this.clearAutoAck();
+        return { type: 9, data };
+    }
+    editReply(body) {
+        return this.options.rest.editOriginal(this.options.interaction.token, body);
+    }
+    followUp(body) {
+        return this.options.rest.createFollowup(this.options.interaction.token, body);
+    }
+    get hasResponded() {
+        return this.responded;
+    }
+    clearAutoAck() {
+        if (this.autoAckTimer)
+            clearTimeout(this.autoAckTimer);
+    }
+}

package/dist/core/interactions/InteractionVerifier.d.ts

@@ -0,0 +1,8 @@
+import type { APIInteraction } from 'discord-api-types/v10';
+export type VerifyInteractionRequest = {
+    body: string | Uint8Array;
+    signature: string;
+    timestamp: string;
+    publicKey: string;
+};
+export declare function verifyAndParseInteraction(request: VerifyInteractionRequest): Promise<APIInteraction>;

package/dist/core/interactions/InteractionVerifier.js

@@ -0,0 +1,9 @@
+import { verifyKey } from 'discord-interactions';
+export async function verifyAndParseInteraction(request) {
+    const valid = await verifyKey(request.body, request.signature, request.timestamp, request.publicKey);
+    if (!valid) {
+        throw new Error('[InteractionVerifier] invalid interaction signature');
+    }
+    const bodyText = typeof request.body === 'string' ? request.body : Buffer.from(request.body).toString('utf8');
+    return JSON.parse(bodyText);
+}

package/dist/core/interactions/__tests__/interaction-context.test.d.ts

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