@minesa-org/mini-interaction 0.4.12 → 0.4.17

package/README.md

@@ -139,6 +139,53 @@ try {
 
 ---
 
+## 🔗 Linked Role Metadata
+
+Register application role connection metadata with `mini.registerMetadata(...)`.
+
+```ts
+import {
+  MiniInteraction,
+  RoleConnectionMetadataTypes,
+} from '@minesa-org/mini-interaction';
+
+const mini = new MiniInteraction({
+  applicationId: process.env.DISCORD_APPLICATION_ID,
+});
+
+await mini.registerMetadata(process.env.DISCORD_BOT_TOKEN!, [
+  {
+    key: 'is_miniapp',
+    name: 'Is Mini App?',
+    description: 'Is the user an assistant?',
+    type: RoleConnectionMetadataTypes.BooleanEqual,
+  },
+]);
+```
+
+Localization maps use `locale -> string` objects for `name_localizations` and `description_localizations`.
+
+```ts
+await mini.registerMetadata(process.env.DISCORD_BOT_TOKEN!, [
+  {
+    key: 'is_miniapp',
+    name: 'Is Mini App?',
+    description: 'Is the user an assistant?',
+    type: RoleConnectionMetadataTypes.BooleanEqual,
+    name_localizations: {
+      tr: 'Mini Uygulama mi?',
+      de: 'Ist Mini-App?',
+    },
+    description_localizations: {
+      tr: 'Kullanici bir assistant mi?',
+      de: 'Benutzer ist ein Assistent?',
+    },
+  },
+]);
+```
+
+---
+
 ## 📜 License
 
 MIT © [Minesa](https://github.com/minesa-org)

package/dist/clients/MiniInteraction.d.ts

@@ -0,0 +1,14 @@
+import { type DiscordRestClientOptions } from "../core/http/DiscordRestClient.js";
+import type { RegisterMetadataResult, RoleConnectionMetadataInput } from "../types/RoleConnectionMetadata.js";
+export type MiniInteractionOptions = {
+    applicationId?: string;
+    apiBaseUrl?: DiscordRestClientOptions["apiBaseUrl"];
+    maxRetries?: DiscordRestClientOptions["maxRetries"];
+    fetchImplementation?: DiscordRestClientOptions["fetchImplementation"];
+};
+export declare class MiniInteraction {
+    private readonly options;
+    constructor(options?: MiniInteractionOptions);
+    get applicationId(): string;
+    registerMetadata(botToken: string, metadata: RoleConnectionMetadataInput[]): Promise<RegisterMetadataResult>;
+}

package/dist/clients/MiniInteraction.js

@@ -0,0 +1,41 @@
+import { DiscordRestClient } from "../core/http/DiscordRestClient.js";
+export class MiniInteraction {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+        const fetchImpl = options.fetchImplementation ?? globalThis.fetch;
+        if (typeof fetchImpl !== "function") {
+            throw new Error("[MiniInteraction] fetch is not available. Provide a global fetch implementation.");
+        }
+    }
+    get applicationId() {
+        const resolvedApplicationId = this.options.applicationId ??
+            (typeof process !== "undefined"
+                ? process.env.DISCORD_APPLICATION_ID
+                : undefined);
+        if (!resolvedApplicationId) {
+            throw new Error("[MiniInteraction] Missing Discord application ID. Set options.applicationId or DISCORD_APPLICATION_ID.");
+        }
+        return resolvedApplicationId;
+    }
+    async registerMetadata(botToken, metadata) {
+        if (!botToken) {
+            throw new Error("[MiniInteraction] botToken is required");
+        }
+        if (!Array.isArray(metadata) || metadata.length === 0) {
+            throw new Error("[MiniInteraction] metadata must be a non-empty array payload");
+        }
+        const rest = new DiscordRestClient({
+            token: botToken,
+            applicationId: this.applicationId,
+            apiBaseUrl: this.options.apiBaseUrl,
+            maxRetries: this.options.maxRetries,
+            fetchImplementation: this.options.fetchImplementation,
+        });
+        const payload = metadata.map((field) => ({
+            ...field,
+            type: field.type,
+        }));
+        return rest.putApplicationRoleConnectionMetadata(payload);
+    }
+}

package/dist/clients/__tests__/MiniInteraction.test.d.ts

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

package/dist/clients/__tests__/MiniInteraction.test.js

@@ -0,0 +1,110 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { MiniInteraction } from "../MiniInteraction.js";
+import { RoleConnectionMetadataTypes } from "../../types/RoleConnectionMetadataTypes.js";
+test("registerMetadata sends the Discord payload and returns the response", async () => {
+    const originalAppId = process.env.DISCORD_APPLICATION_ID;
+    process.env.DISCORD_APPLICATION_ID = "app_123";
+    const calls = [];
+    const fetchImpl = (async (input, init) => {
+        calls.push({ input: String(input), init });
+        return new Response(JSON.stringify([
+            {
+                key: "is_miniapp",
+                name: "Is Mini App?",
+                description: "Is the user an assistant?",
+                type: RoleConnectionMetadataTypes.BooleanEqual,
+                name_localizations: { tr: "Mini Uygulama mi?" },
+                description_localizations: { tr: "Kullanici bir assistant mi?" },
+            },
+        ]), { status: 200 });
+    });
+    try {
+        const mini = new MiniInteraction({ fetchImplementation: fetchImpl });
+        const metadata = await mini.registerMetadata("bot-token", [
+            {
+                key: "is_miniapp",
+                name: "Is Mini App?",
+                description: "Is the user an assistant?",
+                type: RoleConnectionMetadataTypes.BooleanEqual,
+                name_localizations: { tr: "Mini Uygulama mi?" },
+                description_localizations: { tr: "Kullanici bir assistant mi?" },
+            },
+        ]);
+        assert.equal(calls.length, 1);
+        assert.equal(calls[0]?.input, "https://discord.com/api/v10/applications/app_123/role-connections/metadata");
+        assert.equal(calls[0]?.init?.method, "PUT");
+        assert.deepEqual(JSON.parse(String(calls[0]?.init?.body)), [
+            {
+                key: "is_miniapp",
+                name: "Is Mini App?",
+                description: "Is the user an assistant?",
+                type: RoleConnectionMetadataTypes.BooleanEqual,
+                name_localizations: { tr: "Mini Uygulama mi?" },
+                description_localizations: { tr: "Kullanici bir assistant mi?" },
+            },
+        ]);
+        assert.deepEqual(metadata, [
+            {
+                key: "is_miniapp",
+                name: "Is Mini App?",
+                description: "Is the user an assistant?",
+                type: RoleConnectionMetadataTypes.BooleanEqual,
+                name_localizations: { tr: "Mini Uygulama mi?" },
+                description_localizations: { tr: "Kullanici bir assistant mi?" },
+            },
+        ]);
+    }
+    finally {
+        if (originalAppId === undefined) {
+            delete process.env.DISCORD_APPLICATION_ID;
+        }
+        else {
+            process.env.DISCORD_APPLICATION_ID = originalAppId;
+        }
+    }
+});
+test("registerMetadata throws when metadata is empty", async () => {
+    const mini = new MiniInteraction({ applicationId: "app_123" });
+    await assert.rejects(() => mini.registerMetadata("bot-token", []), /\[MiniInteraction\] metadata must be a non-empty array payload/);
+});
+test("registerMetadata throws when application id cannot be resolved", async () => {
+    const originalAppId = process.env.DISCORD_APPLICATION_ID;
+    delete process.env.DISCORD_APPLICATION_ID;
+    try {
+        const mini = new MiniInteraction();
+        await assert.rejects(() => mini.registerMetadata("bot-token", [
+            {
+                key: "is_miniapp",
+                name: "Is Mini App?",
+                description: "Is the user an assistant?",
+                type: RoleConnectionMetadataTypes.BooleanEqual,
+            },
+        ]), /\[MiniInteraction\] Missing Discord application ID/);
+    }
+    finally {
+        if (originalAppId === undefined) {
+            delete process.env.DISCORD_APPLICATION_ID;
+        }
+        else {
+            process.env.DISCORD_APPLICATION_ID = originalAppId;
+        }
+    }
+});
+test("registerMetadata includes the response body in thrown errors", async () => {
+    const fetchImpl = (async () => new Response(JSON.stringify({ message: "Bad metadata" }), {
+        status: 400,
+    }));
+    const mini = new MiniInteraction({
+        applicationId: "app_123",
+        fetchImplementation: fetchImpl,
+    });
+    await assert.rejects(() => mini.registerMetadata("bot-token", [
+        {
+            key: "is_miniapp",
+            name: "Is Mini App?",
+            description: "Is the user an assistant?",
+            type: RoleConnectionMetadataTypes.BooleanEqual,
+        },
+    ]), /\[DiscordRestClient\] PUT \/applications\/app_123\/role-connections\/metadata failed: 400 {"message":"Bad metadata"}/);
+});

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

@@ -1,3 +1,7 @@
+import type { APIChannel, RESTPutAPIApplicationRoleConnectionMetadataJSONBody, RESTPutAPIApplicationRoleConnectionMetadataResult } from 'discord-api-types/v10';
+import { DiscordSentMessage } from '../messages/DiscordSentMessage.js';
+import { type BaseDiscordMessageOptions, type DiscordReaction, type DiscordSendMessageOptions, type DiscordStartThreadOptions } from '../messages/message-payloads.js';
+import { DiscordWebhook } from '../webhooks/DiscordWebhook.js';
 type FetchLike = typeof fetch;
 export type DiscordRestClientOptions = {
     token: string;
@@ -18,5 +22,13 @@ export declare class DiscordRestClient {
     private createRequestError;
     createFollowup(interactionToken: string, body: unknown): Promise<unknown>;
     editOriginal(interactionToken: string, body: unknown): Promise<unknown>;
+    createFollowupMessage(interactionToken: string, options: BaseDiscordMessageOptions): Promise<DiscordSentMessage>;
+    editOriginalMessage(interactionToken: string, options: BaseDiscordMessageOptions): Promise<DiscordSentMessage>;
+    sendMessage(options: DiscordSendMessageOptions): Promise<DiscordSentMessage>;
+    send(options: DiscordSendMessageOptions): Promise<DiscordSentMessage>;
+    startThread(options: DiscordStartThreadOptions): Promise<APIChannel>;
+    addReaction(channelId: string, messageId: string, reaction: DiscordReaction): Promise<void>;
+    webhook(id: string, token: string): DiscordWebhook;
+    putApplicationRoleConnectionMetadata(body: RESTPutAPIApplicationRoleConnectionMetadataJSONBody): Promise<RESTPutAPIApplicationRoleConnectionMetadataResult>;
 }
 export {};

package/dist/core/http/DiscordRestClient.js

@@ -1,4 +1,7 @@
 import { setTimeout as sleep } from 'node:timers/promises';
+import { DiscordSentMessage } from '../messages/DiscordSentMessage.js';
+import { createMessageRequestInit, } from '../messages/message-payloads.js';
+import { DiscordWebhook } from '../webhooks/DiscordWebhook.js';
 export class DiscordRestClient {
     options;
     fetchImpl;
@@ -20,7 +23,7 @@ export class DiscordRestClient {
                     ...requestInit,
                     headers: {
                         ...(authenticated ? { Authorization: `Bot ${this.options.token}` } : {}),
-                        'Content-Type': 'application/json',
+                        ...getDefaultContentTypeHeader(requestInit.body),
                         ...(requestInit.headers ?? {}),
                     },
                 });
@@ -45,13 +48,17 @@ export class DiscordRestClient {
             if (response.ok) {
                 if (response.status === 204)
                     return undefined;
-                return (await response.json());
+                const responseText = await response.text();
+                if (!responseText)
+                    return undefined;
+                return JSON.parse(responseText);
             }
             if (response.status >= 500 && attempt < this.maxRetries) {
                 await sleep(150 * (attempt + 1));
                 continue;
             }
-            lastError = new Error(`[DiscordRestClient] ${requestInit.method ?? 'GET'} ${path} failed: ${response.status}`);
+            const errorBody = await response.text();
+            lastError = new Error(`[DiscordRestClient] ${requestInit.method ?? 'GET'} ${path} failed: ${response.status}${errorBody ? ` ${errorBody}` : ''}`);
             break;
         }
         throw lastError instanceof Error ? lastError : new Error('[DiscordRestClient] unknown request failure');
@@ -74,4 +81,78 @@ export class DiscordRestClient {
             authenticated: false,
         });
     }
+    async createFollowupMessage(interactionToken, options) {
+        const requestInit = createMessageRequestInit(options);
+        const message = await this.request(`/webhooks/${this.options.applicationId}/${interactionToken}`, {
+            method: 'POST',
+            ...requestInit,
+            authenticated: false,
+        });
+        return new DiscordSentMessage(this, message);
+    }
+    async editOriginalMessage(interactionToken, options) {
+        const requestInit = createMessageRequestInit(options);
+        const message = await this.request(`/webhooks/${this.options.applicationId}/${interactionToken}/messages/@original`, {
+            method: 'PATCH',
+            ...requestInit,
+            authenticated: false,
+        });
+        return new DiscordSentMessage(this, message);
+    }
+    async sendMessage(options) {
+        const { channelId, ...messageOptions } = options;
+        const requestInit = createMessageRequestInit(messageOptions);
+        const message = await this.request(`/channels/${channelId}/messages`, {
+            method: 'POST',
+            ...requestInit,
+        });
+        return new DiscordSentMessage(this, message);
+    }
+    send(options) {
+        return this.sendMessage(options);
+    }
+    async startThread(options) {
+        const { channelId, messageId, reason, ...body } = options;
+        return this.request(`/channels/${channelId}/messages/${messageId}/threads`, {
+            method: 'POST',
+            body: JSON.stringify({
+                auto_archive_duration: body.autoArchiveDuration,
+                rate_limit_per_user: body.rateLimitPerUser,
+                name: body.name,
+            }),
+            headers: reason ? { 'X-Audit-Log-Reason': reason } : undefined,
+        });
+    }
+    addReaction(channelId, messageId, reaction) {
+        return this.request(`/channels/${channelId}/messages/${messageId}/reactions/${encodeDiscordReaction(reaction)}/@me`, {
+            method: 'PUT',
+        });
+    }
+    webhook(id, token) {
+        return new DiscordWebhook(this, id, token);
+    }
+    putApplicationRoleConnectionMetadata(body) {
+        return this.request(`/applications/${this.options.applicationId}/role-connections/metadata`, {
+            method: 'PUT',
+            body: JSON.stringify(body),
+        });
+    }
+}
+function getDefaultContentTypeHeader(body) {
+    return body instanceof FormData ? {} : { 'Content-Type': 'application/json' };
+}
+function encodeDiscordReaction(reaction) {
+    if (typeof reaction !== 'string') {
+        return encodeURIComponent(reaction.id ? `${reaction.name}:${reaction.id}` : reaction.name);
+    }
+    const trimmed = reaction.trim();
+    const customEmojiMatch = trimmed.match(/^<a?:([^:>]+):(\d+)>$/);
+    if (customEmojiMatch) {
+        const [, name, id] = customEmojiMatch;
+        return encodeURIComponent(`${name}:${id}`);
+    }
+    if (/^[^:\s]+:\d+$/.test(trimmed)) {
+        return encodeURIComponent(trimmed);
+    }
+    return encodeURIComponent(trimmed);
 }

package/dist/core/http/__tests__/discord-rest-client.messages.test.d.ts

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

package/dist/core/http/__tests__/discord-rest-client.messages.test.js

@@ -0,0 +1,122 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { MessageFlags } from "discord-api-types/v10";
+import { ContainerBuilder, TextDisplayBuilder } from "../../../builders/index.js";
+import { DiscordRestClient } from "../DiscordRestClient.js";
+test("sendMessage sends channel messages and returns a thread-capable wrapper", async () => {
+    const calls = [];
+    const fetchImpl = (async (input, init) => {
+        calls.push({ input: String(input), init: init ?? {} });
+        if (calls.length === 1) {
+            return new Response(JSON.stringify({ id: "msg_1", channel_id: "chan_1" }), { status: 200 });
+        }
+        return new Response(JSON.stringify({ id: "thread_1", type: 11, parent_id: "chan_1" }), { status: 200 });
+    });
+    const rest = new DiscordRestClient({
+        token: "token",
+        applicationId: "app",
+        fetchImplementation: fetchImpl,
+    });
+    const container = new ContainerBuilder().addComponent(new TextDisplayBuilder().setContent("Hello"));
+    const sentMessage = await rest.send({
+        channelId: "chan_1",
+        components: [container],
+        flags: MessageFlags.IsComponentsV2,
+    });
+    assert.equal(sentMessage.id, "msg_1");
+    await sentMessage.startThread({
+        name: "Thread name",
+        autoArchiveDuration: 60,
+        reason: "Testing",
+    });
+    assert.equal(calls.length, 2);
+    assert.match(calls[0].input, /\/channels\/chan_1\/messages$/);
+    assert.match(calls[1].input, /\/channels\/chan_1\/messages\/msg_1\/threads$/);
+    assert.match(String(calls[0].init.body), /payload|components|flags/);
+});
+test("sentMessage.react supports custom emoji strings and emoji objects", async () => {
+    const calls = [];
+    const fetchImpl = (async (input, init) => {
+        calls.push({ input: String(input), init: init ?? {} });
+        if (calls.length === 1) {
+            return new Response(JSON.stringify({ id: "msg_react", channel_id: "chan_react" }), { status: 200 });
+        }
+        return new Response(null, { status: 204 });
+    });
+    const rest = new DiscordRestClient({
+        token: "token",
+        applicationId: "app",
+        fetchImplementation: fetchImpl,
+    });
+    const sentMessage = await rest.sendMessage({
+        channelId: "chan_react",
+        content: "React to me",
+    });
+    await sentMessage.react("<:wave:1234567890>");
+    await sentMessage.react({ name: "thumbsup", id: "999" });
+    assert.equal(calls.length, 3);
+    assert.match(calls[1].input, /\/channels\/chan_react\/messages\/msg_react\/reactions\/wave%3A1234567890\/@me$/);
+    assert.match(calls[2].input, /\/channels\/chan_react\/messages\/msg_react\/reactions\/thumbsup%3A999\/@me$/);
+});
+test("sendMessage uses multipart form-data when files are provided", async () => {
+    let capturedBody;
+    const fetchImpl = (async (_input, init) => {
+        capturedBody = init?.body;
+        return new Response(JSON.stringify({ id: "msg_file", channel_id: "chan_file" }), { status: 200 });
+    });
+    const rest = new DiscordRestClient({
+        token: "token",
+        applicationId: "app",
+        fetchImplementation: fetchImpl,
+    });
+    await rest.sendMessage({
+        channelId: "chan_file",
+        content: "with file",
+        files: [
+            {
+                name: "hello.txt",
+                data: new TextEncoder().encode("hello world"),
+                contentType: "text/plain",
+            },
+        ],
+    });
+    assert.ok(capturedBody instanceof FormData);
+    const payloadJson = capturedBody.get("payload_json");
+    assert.equal(typeof payloadJson, "string");
+    assert.match(String(payloadJson), /hello\.txt/);
+});
+test("webhook.send returns a sent message wrapper", async () => {
+    const calls = [];
+    const fetchImpl = (async (input, init) => {
+        calls.push({ input: String(input), init: init ?? {} });
+        return new Response(JSON.stringify({ id: "msg_hook", channel_id: "chan_hook" }), { status: 200 });
+    });
+    const rest = new DiscordRestClient({
+        token: "token",
+        applicationId: "app",
+        fetchImplementation: fetchImpl,
+    });
+    const webhook = rest.webhook("wh_1", "wh_token");
+    const sentMessage = await webhook.send({
+        content: "hello",
+        threadId: "thread_123",
+        username: "Mini",
+    });
+    assert.equal(sentMessage.id, "msg_hook");
+    assert.match(calls[0].input, /\/webhooks\/wh_1\/wh_token\?wait=true&thread_id=thread_123$/);
+    assert.match(String(calls[0].init.body), /"username":"Mini"/);
+});
+test("sendMessage rejects ephemeral flags for regular messages", async () => {
+    const rest = new DiscordRestClient({
+        token: "token",
+        applicationId: "app",
+        fetchImplementation: (async () => new Response(JSON.stringify({ id: "x", channel_id: "y" }), {
+            status: 200,
+        })),
+    });
+    await assert.rejects(() => rest.sendMessage({
+        channelId: "chan",
+        content: "nope",
+        flags: MessageFlags.Ephemeral,
+    }), /regular channel or webhook messages/);
+});

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

@@ -1,6 +1,8 @@
 import type { APIInteractionResponse, APIInteractionResponseCallbackData, APIModalInteractionResponseCallbackData } from 'discord-api-types/v10';
 import type { ParsedInteraction } from '../../types/discord.js';
 import { DiscordRestClient } from '../http/DiscordRestClient.js';
+import type { DiscordSentMessage } from '../messages/DiscordSentMessage.js';
+import type { BaseDiscordMessageOptions, DiscordSendMessageOptions } from '../messages/message-payloads.js';
 export type InteractionContextOptions = {
     interaction: ParsedInteraction;
     rest: DiscordRestClient;
@@ -18,8 +20,9 @@ export declare class InteractionContext {
     reply(data: APIInteractionResponseCallbackData): APIInteractionResponse;
     deferReply(ephemeral?: boolean): APIInteractionResponse;
     showModal(data: APIModalInteractionResponseCallbackData): APIInteractionResponse;
-    editReply(body: unknown): Promise<unknown>;
-    followUp(body: unknown): Promise<unknown>;
+    editReply(body: BaseDiscordMessageOptions): Promise<DiscordSentMessage>;
+    followUp(body: BaseDiscordMessageOptions): Promise<DiscordSentMessage>;
+    send(body: DiscordSendMessageOptions): Promise<DiscordSentMessage>;
     get hasResponded(): boolean;
     private clearAutoAck;
 }

package/dist/core/interactions/InteractionContext.js

@@ -29,10 +29,13 @@ export class InteractionContext {
         return { type: 9, data };
     }
     editReply(body) {
-        return this.options.rest.editOriginal(this.options.interaction.token, body);
+        return this.options.rest.editOriginalMessage(this.options.interaction.token, body);
     }
     followUp(body) {
-        return this.options.rest.createFollowup(this.options.interaction.token, body);
+        return this.options.rest.createFollowupMessage(this.options.interaction.token, body);
+    }
+    send(body) {
+        return this.options.rest.sendMessage(body);
     }
     get hasResponded() {
         return this.responded;

package/dist/core/messages/DiscordSentMessage.d.ts

@@ -0,0 +1,13 @@
+import type { APIChannel, APIMessage } from "discord-api-types/v10";
+import type { DiscordRestClient } from "../http/DiscordRestClient.js";
+import type { DiscordReaction, DiscordStartThreadOptions } from "./message-payloads.js";
+export declare class DiscordSentMessage {
+    private readonly rest;
+    readonly raw: APIMessage;
+    constructor(rest: DiscordRestClient, raw: APIMessage);
+    get id(): string;
+    get channelId(): string;
+    startThread(options: Omit<DiscordStartThreadOptions, "channelId" | "messageId">): Promise<APIChannel>;
+    react(reaction: DiscordReaction): Promise<this>;
+    toJSON(): APIMessage;
+}

package/dist/core/messages/DiscordSentMessage.js

@@ -0,0 +1,28 @@
+export class DiscordSentMessage {
+    rest;
+    raw;
+    constructor(rest, raw) {
+        this.rest = rest;
+        this.raw = raw;
+    }
+    get id() {
+        return this.raw.id;
+    }
+    get channelId() {
+        return this.raw.channel_id;
+    }
+    async startThread(options) {
+        return this.rest.startThread({
+            channelId: this.channelId,
+            messageId: this.id,
+            ...options,
+        });
+    }
+    async react(reaction) {
+        await this.rest.addReaction(this.channelId, this.id, reaction);
+        return this;
+    }
+    toJSON() {
+        return this.raw;
+    }
+}

package/dist/core/messages/message-payloads.d.ts

@@ -0,0 +1,40 @@
+import type { APIAllowedMentions } from "discord-api-types/v10";
+import { type InteractionMessageData, type MessageFlagLike } from "../../utils/interactionMessageHelpers.js";
+export type DiscordMessageFile = {
+    name: string;
+    data: ArrayBuffer | Blob | Buffer | Uint8Array;
+    contentType?: string;
+};
+export type BaseDiscordMessageOptions = Omit<InteractionMessageData, "flags"> & {
+    flags?: MessageFlagLike | MessageFlagLike[];
+    allowedMentions?: APIAllowedMentions;
+    attachments?: Array<Record<string, unknown>>;
+    stickerIds?: string[];
+    files?: DiscordMessageFile[];
+};
+export type DiscordSendMessageOptions = BaseDiscordMessageOptions & {
+    channelId: string;
+};
+export type DiscordStartThreadOptions = {
+    channelId: string;
+    messageId: string;
+    name: string;
+    autoArchiveDuration?: number;
+    rateLimitPerUser?: number;
+    reason?: string;
+};
+export type DiscordWebhookSendOptions = BaseDiscordMessageOptions & {
+    threadId?: string;
+    username?: string;
+    avatarUrl?: string;
+};
+export type DiscordReaction = string | {
+    name: string;
+    id?: string;
+    animated?: boolean;
+};
+export declare function normaliseDiscordMessagePayload(options: BaseDiscordMessageOptions): Record<string, unknown>;
+export declare function createMessageRequestInit(options: BaseDiscordMessageOptions): {
+    body: BodyInit;
+    headers?: HeadersInit;
+};

package/dist/core/messages/message-payloads.js

@@ -0,0 +1,60 @@
+import { MessageFlags } from "discord-api-types/v10";
+import { normaliseInteractionMessageData, } from "../../utils/interactionMessageHelpers.js";
+export function normaliseDiscordMessagePayload(options) {
+    const payload = normaliseInteractionMessageData({
+        content: options.content,
+        components: options.components,
+        embeds: options.embeds,
+        flags: options.flags,
+    });
+    const resolvedPayload = payload ? { ...payload } : {};
+    const flags = resolvedPayload.flags;
+    if (typeof flags === "number" && (flags & MessageFlags.Ephemeral) === MessageFlags.Ephemeral) {
+        throw new Error("[MiniInteraction] Ephemeral flags are not supported for regular channel or webhook messages.");
+    }
+    if (options.allowedMentions) {
+        resolvedPayload.allowed_mentions = options.allowedMentions;
+    }
+    if (options.stickerIds && options.stickerIds.length > 0) {
+        resolvedPayload.sticker_ids = options.stickerIds;
+    }
+    const files = options.files ?? [];
+    if (options.attachments && options.attachments.length > 0) {
+        resolvedPayload.attachments = options.attachments;
+    }
+    else if (files.length > 0) {
+        resolvedPayload.attachments = files.map((file, index) => ({
+            id: String(index),
+            filename: file.name,
+        }));
+    }
+    return resolvedPayload;
+}
+export function createMessageRequestInit(options) {
+    const payload = normaliseDiscordMessagePayload(options);
+    const files = options.files ?? [];
+    if (files.length === 0) {
+        return {
+            body: JSON.stringify(payload),
+            headers: {
+                "Content-Type": "application/json",
+            },
+        };
+    }
+    const formData = new FormData();
+    formData.set("payload_json", JSON.stringify(payload));
+    files.forEach((file, index) => {
+        formData.append(`files[${index}]`, toBlob(file), file.name);
+    });
+    return { body: formData };
+}
+function toBlob(file) {
+    if (file.data instanceof Blob) {
+        return file.data;
+    }
+    if (file.data instanceof ArrayBuffer) {
+        return new Blob([file.data], file.contentType ? { type: file.contentType } : undefined);
+    }
+    const bytes = Uint8Array.from(file.data);
+    return new Blob([bytes.buffer], file.contentType ? { type: file.contentType } : undefined);
+}

package/dist/core/webhooks/DiscordWebhook.d.ts

@@ -0,0 +1,10 @@
+import type { DiscordRestClient } from "../http/DiscordRestClient.js";
+import { DiscordSentMessage } from "../messages/DiscordSentMessage.js";
+import { type DiscordWebhookSendOptions } from "../messages/message-payloads.js";
+export declare class DiscordWebhook {
+    private readonly rest;
+    readonly id: string;
+    readonly token: string;
+    constructor(rest: DiscordRestClient, id: string, token: string);
+    send(options: DiscordWebhookSendOptions): Promise<DiscordSentMessage>;
+}

package/dist/core/webhooks/DiscordWebhook.js

@@ -0,0 +1,47 @@
+import { DiscordSentMessage } from "../messages/DiscordSentMessage.js";
+import { createMessageRequestInit, } from "../messages/message-payloads.js";
+export class DiscordWebhook {
+    rest;
+    id;
+    token;
+    constructor(rest, id, token) {
+        this.rest = rest;
+        this.id = id;
+        this.token = token;
+    }
+    async send(options) {
+        const { threadId, username, avatarUrl, ...messageOptions } = options;
+        const requestInit = createMessageRequestInit(messageOptions);
+        const searchParams = new URLSearchParams({ wait: "true" });
+        if (threadId) {
+            searchParams.set("thread_id", threadId);
+        }
+        const message = await this.rest.request(`/webhooks/${this.id}/${this.token}?${searchParams.toString()}`, {
+            method: "POST",
+            body: appendWebhookPayload(requestInit.body, {
+                username,
+                avatar_url: avatarUrl,
+            }),
+            headers: requestInit.headers,
+            authenticated: false,
+        });
+        return new DiscordSentMessage(this.rest, message);
+    }
+}
+function appendWebhookPayload(body, webhookOverrides) {
+    if (body instanceof FormData) {
+        const payload = JSON.parse(String(body.get("payload_json") ?? "{}"));
+        if (webhookOverrides.username)
+            payload.username = webhookOverrides.username;
+        if (webhookOverrides.avatar_url)
+            payload.avatar_url = webhookOverrides.avatar_url;
+        body.set("payload_json", JSON.stringify(payload));
+        return body;
+    }
+    const payload = JSON.parse(String(body));
+    if (webhookOverrides.username)
+        payload.username = webhookOverrides.username;
+    if (webhookOverrides.avatar_url)
+        payload.avatar_url = webhookOverrides.avatar_url;
+    return JSON.stringify(payload);
+}

package/dist/index.d.ts

@@ -12,6 +12,7 @@ export { ChannelType } from "./types/ChannelType.js";
 export { InteractionFlags, } from "./types/InteractionFlags.js";
 export { ButtonStyle } from "./types/ButtonStyle.js";
 export { SeparatorSpacingSize } from "./types/SeparatorSpacingSize.js";
+export { MessageFlags, type APIAllowedMentions } from "discord-api-types/v10";
 export { TextInputStyle } from "discord-api-types/v10";
 export { MiniPermFlags } from "./types/PermissionFlags.js";
 export type { ActionRowComponent, MessageActionRowComponent, InteractionComponentData, } from "./types/ComponentTypes.js";
@@ -24,8 +25,12 @@ export { MiniDatabase } from "./database/MiniDatabase.js";
 export { generateOAuthUrl, getOAuthTokens, refreshAccessToken, getDiscordUser, ensureValidToken, } from "./oauth/DiscordOAuth.js";
 export type { OAuthConfig, OAuthTokens, DiscordUser, } from "./oauth/DiscordOAuth.js";
 export { OAuthTokenStorage } from "./oauth/OAuthTokenStorage.js";
+export type { DiscordLocale, LocalizationMap, RegisterMetadataResult, RoleConnectionMetadata, RoleConnectionMetadataInput, } from "./types/RoleConnectionMetadata.js";
 export { DiscordRestClient } from "./core/http/DiscordRestClient.js";
 export type { DiscordRestClientOptions } from "./core/http/DiscordRestClient.js";
+export { DiscordSentMessage } from "./core/messages/DiscordSentMessage.js";
+export type { DiscordMessageFile, DiscordReaction, DiscordSendMessageOptions, DiscordStartThreadOptions, DiscordWebhookSendOptions, } from "./core/messages/message-payloads.js";
+export { DiscordWebhook } from "./core/webhooks/DiscordWebhook.js";
 export { InteractionContext } from "./core/interactions/InteractionContext.js";
 export type { InteractionContextOptions } from "./core/interactions/InteractionContext.js";
 export { verifyAndParseInteraction } from "./core/interactions/InteractionVerifier.js";

package/dist/index.js

@@ -10,6 +10,7 @@ export { ChannelType } from "./types/ChannelType.js";
 export { InteractionFlags, } from "./types/InteractionFlags.js";
 export { ButtonStyle } from "./types/ButtonStyle.js";
 export { SeparatorSpacingSize } from "./types/SeparatorSpacingSize.js";
+export { MessageFlags } from "discord-api-types/v10";
 export { TextInputStyle } from "discord-api-types/v10";
 export { MiniPermFlags } from "./types/PermissionFlags.js";
 export * from "./builders/index.js";
@@ -20,6 +21,8 @@ export { generateOAuthUrl, getOAuthTokens, refreshAccessToken, getDiscordUser, e
 export { OAuthTokenStorage } from "./oauth/OAuthTokenStorage.js";
 // New v10 core modules
 export { DiscordRestClient } from "./core/http/DiscordRestClient.js";
+export { DiscordSentMessage } from "./core/messages/DiscordSentMessage.js";
+export { DiscordWebhook } from "./core/webhooks/DiscordWebhook.js";
 export { InteractionContext } from "./core/interactions/InteractionContext.js";
 export { verifyAndParseInteraction } from "./core/interactions/InteractionVerifier.js";
 export { InteractionRouter } from "./router/InteractionRouter.js";

package/dist/types/RoleConnectionMetadata.d.ts

@@ -0,0 +1,14 @@
+import type { APIApplicationRoleConnectionMetadata, Locale, RESTPutAPIApplicationRoleConnectionMetadataResult } from "discord-api-types/v10";
+import type { RoleConnectionMetadataTypes } from "./RoleConnectionMetadataTypes.js";
+export type DiscordLocale = `${Locale}`;
+export type LocalizationMap = Partial<Record<DiscordLocale, string>>;
+export type RoleConnectionMetadataInput = {
+    key: string;
+    name: string;
+    description: string;
+    type: RoleConnectionMetadataTypes;
+    name_localizations?: LocalizationMap;
+    description_localizations?: LocalizationMap;
+};
+export type RoleConnectionMetadata = APIApplicationRoleConnectionMetadata;
+export type RegisterMetadataResult = RESTPutAPIApplicationRoleConnectionMetadataResult;

package/dist/types/RoleConnectionMetadata.js

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

package/package.json

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