@zhin.js/adapter-discord 1.0.86 → 1.1.0

package/lib/endpoint.d.ts

@@ -0,0 +1,72 @@
+import { Endpoint } from 'zhin.js/adapter';
+import type { EndpointContentPort, EndpointControl, EndpointManagement, EndpointSendRequest } from 'zhin.js/adapter';
+import type { HttpHost } from '@zhin.js/host-http';
+import { type MessageRef } from '@zhin.js/im-contract';
+import type { CapabilityId } from 'zhin.js';
+import { type CreateDiscordClient, type DiscordClientTransport } from './gateway.js';
+import { type DiscordButtonInbound, type DiscordInboundMessage, type ResolvedDiscordGatewayConfig, type ResolvedDiscordInteractionsConfig } from './protocol.js';
+export type { CreateDiscordClient, DiscordClientTransport, } from './gateway.js';
+export interface DiscordEndpointOptions {
+    readonly id: CapabilityId;
+    readonly config: ResolvedDiscordGatewayConfig;
+    readonly createClient?: CreateDiscordClient;
+    readonly fetch?: typeof globalThis.fetch;
+}
+export declare class DiscordGatewayEndpoint extends Endpoint<DiscordClientTransport> {
+    #private;
+    readonly management: EndpointManagement;
+    readonly control: EndpointControl;
+    readonly content: EndpointContentPort;
+    constructor(options: DiscordEndpointOptions);
+    /** The actual discord.js-compatible client used by this connection. */
+    get client(): DiscordClientTransport;
+    start(): Promise<void>;
+    open(): void;
+    close(): void;
+    stop(): Promise<void>;
+    send({ conversation, payload }: EndpointSendRequest): Promise<string>;
+    recallMessage(message: MessageRef): Promise<void>;
+    /** Test / internal: admit a message when open. */
+    admit(msg: DiscordInboundMessage): void;
+    /** Test / internal: admit a button interaction when open. */
+    admitButton(interaction: DiscordButtonInbound): void;
+}
+export interface DiscordInteractionsEndpointOptions {
+    readonly id: CapabilityId;
+    readonly http: HttpHost;
+    readonly config: ResolvedDiscordInteractionsConfig;
+    readonly fetch?: typeof globalThis.fetch;
+}
+/** Minimal Discord REST client used when Gateway is intentionally disabled. */
+export declare class DiscordRestClient {
+    readonly token: string;
+    readonly fetch: typeof globalThis.fetch;
+    constructor(token: string, fetch?: typeof globalThis.fetch);
+    request<T = unknown>(method: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE', path: string, body?: unknown): Promise<T>;
+    createMessage(channelId: string, body: unknown): Promise<{
+        id?: string;
+    }>;
+    deleteMessage(channelId: string, messageId: string): Promise<void>;
+}
+export declare class DiscordInteractionsEndpoint extends Endpoint<DiscordRestClient> {
+    #private;
+    readonly client: DiscordRestClient;
+    readonly control: EndpointControl;
+    readonly content: EndpointContentPort;
+    constructor(options: DiscordInteractionsEndpointOptions);
+    get isOpen(): boolean;
+    get config(): ResolvedDiscordInteractionsConfig;
+    start(): Promise<void>;
+    open(): void;
+    close(): void;
+    stop(): Promise<void>;
+    send({ conversation, payload }: EndpointSendRequest): Promise<string>;
+    recallMessage(message: MessageRef): Promise<void>;
+    admit(msg: DiscordInboundMessage): void;
+    admitPlatform(event: Record<string, unknown>): void;
+}
+/**
+ * DiscordGatewayEndpoint 的 EndpointManagement 语义端口（参照 qq 的工厂模式）。
+ * 数据源为 discord.js SDK 缓存：guilds.cache / guild.channels.cache / guild.members。
+ */
+export declare function createDiscordEndpointManagement(requireClient: () => DiscordClientTransport): EndpointManagement;

package/lib/endpoint.js

@@ -0,0 +1,458 @@
+import { Endpoint } from 'zhin.js/adapter';
+/**
+ * DiscordEndpoint — lifecycle, outbound, admit, gateway / interactions modes, agent tool surface.
+ */
+import { ChannelType } from 'discord.js';
+import { formatCompact, getAdapterLogger } from '@zhin.js/logger';
+import { connectDiscordGatewayClient, defaultCreateClient, DEFAULT_INTENTS, resolveSenderRole, toMessageCreateOptions, } from './gateway.js';
+import { discordInboundConversation, formatButtonContent, formatButtonSegments, formatInboundContent, formatInboundSegments, formatOutboundBody, senderDisplayName, } from './protocol.js';
+import { registerDiscordInteractionRoutes } from './webhook.js';
+import { receiveDiscordGuildMemberSideEvent } from './side-event-dispatch.js';
+const DISCORD_API = 'https://discord.com/api/v10';
+/** 出站 HTTP 调用统一 30s 超时。 */
+const OUTBOUND_TIMEOUT_MS = 30_000;
+export class DiscordGatewayEndpoint extends Endpoint {
+    #logger;
+    #options;
+    #createClient;
+    #fetch;
+    #client = null;
+    #open = false;
+    #started = false;
+    management = createDiscordEndpointManagement(() => this.#requireClient());
+    control = Object.freeze({
+        recall: (message) => this.recallMessage(message),
+        addReaction: async (message, emoji, hint) => {
+            const channelId = hint?.channelId ?? message.conversation.id;
+            if (!channelId || !message.id)
+                return null;
+            await this.#addReaction(channelId, message.id, emoji);
+            return emoji;
+        },
+    });
+    content = Object.freeze({
+        resolve: (reference, context) => resolveDiscordContent(this.#fetch, this.#options.config.token, reference, context),
+    });
+    constructor(options) {
+        super();
+        this.#logger = getAdapterLogger('discord', options.config.id);
+        this.#options = options;
+        this.#createClient = options.createClient ?? defaultCreateClient;
+        this.#fetch = options.fetch ?? globalThis.fetch;
+    }
+    /** The actual discord.js-compatible client used by this connection. */
+    get client() {
+        return this.#requireClient();
+    }
+    async start() {
+        if (this.#started)
+            return;
+        this.#started = true;
+        try {
+            const intents = this.#options.config.intents?.length
+                ? [...this.#options.config.intents]
+                : DEFAULT_INTENTS;
+            this.#client = this.#createClient(intents);
+            await connectDiscordGatewayClient(this.#client, this.#options.config, {
+                onPlatformEvent: (name, event) => {
+                    void this.#emitPlatformEvent(name, event);
+                },
+                onMessage: (msg) => this.admit(msg),
+                onButton: (interaction) => this.admitButton(interaction),
+                onGuildMemberAdd: (member) => {
+                    receiveDiscordGuildMemberSideEvent((name, payload) => this.emit(name, payload), this.#options.config.id, 'member_increase', member, this.#logger);
+                },
+                onGuildMemberRemove: (member) => {
+                    receiveDiscordGuildMemberSideEvent((name, payload) => this.emit(name, payload), this.#options.config.id, 'member_decrease', member, this.#logger);
+                },
+            });
+            this.#logger.info(formatCompact({
+                op: 'connect',
+                endpoint: this.#options.config.id,
+                mode: 'gateway',
+                user: this.#client.user?.tag,
+            }));
+        }
+        catch (error) {
+            await this.stop();
+            this.#logger.error('Failed to connect Discord gateway:', error);
+            throw error;
+        }
+    }
+    open() {
+        this.#open = true;
+    }
+    close() {
+        this.#open = false;
+    }
+    async stop() {
+        this.#open = false;
+        if (this.#client) {
+            try {
+                this.#client.removeAllListeners();
+                await this.#client.destroy();
+            }
+            catch {
+                /* ignore */
+            }
+            this.#client = null;
+        }
+        this.#started = false;
+        this.#logger.debug(formatCompact({ op: 'disconnect' }));
+    }
+    async send({ conversation, payload }) {
+        const body = formatOutboundBody(payload);
+        const snowflake = await this.#sendBody(conversation.id, body);
+        this.#logger.debug(formatCompact({
+            op: 'discord_send',
+            endpoint: this.#options.config.id,
+            target: conversation.id,
+            messageId: snowflake,
+        }));
+        return snowflake;
+    }
+    async recallMessage(message) {
+        if (!message.id)
+            return;
+        const channel = await this.#requireClient().channels.fetch(message.conversation.id);
+        if (!channel?.isTextBased() || !channel.messages)
+            return;
+        const msg = await channel.messages.fetch(message.id);
+        await msg.delete();
+    }
+    /** Test / internal: admit a message when open. */
+    admit(msg) {
+        if (!this.#open)
+            return;
+        if (msg.authorBot)
+            return;
+        const conversation = discordInboundConversation(String(this.#options.id), msg);
+        void this.emit('message.receive', {
+            conversation,
+            message: { conversation, id: msg.id },
+            content: formatInboundContent(msg),
+            segments: formatInboundSegments(msg),
+            sender: {
+                id: msg.authorId,
+                name: senderDisplayName(msg) || undefined,
+                ...(resolveSenderRole(msg) ? { roles: [resolveSenderRole(msg)] } : {}),
+            },
+            endpointId: this.#options.config.id,
+            ...(msg.mentionedBot ? { mentioned: true } : {}),
+            metadata: Object.freeze({
+                channelKind: msg.channelKind,
+                userId: msg.authorId,
+                guildId: msg.guildId,
+                permissions: msg.permissionTokens,
+                role: resolveSenderRole(msg),
+            }),
+        }).catch((err) => {
+            this.#logger.warn(formatCompact({
+                op: 'discord_gateway_receive_failed',
+                target: `${conversation.kind}:${conversation.id}`,
+                error: err instanceof Error ? err.message : String(err),
+            }));
+        });
+    }
+    /** Test / internal: admit a button interaction when open. */
+    admitButton(interaction) {
+        if (!this.#open)
+            return;
+        const conversation = discordInboundConversation(String(this.#options.id), interaction);
+        void this.emit('message.receive', {
+            conversation,
+            message: { conversation, id: interaction.id },
+            content: formatButtonContent(interaction),
+            segments: formatButtonSegments(interaction),
+            sender: { id: interaction.userId, name: interaction.userName },
+            endpointId: this.#options.config.id,
+            metadata: Object.freeze({
+                eventType: 'button',
+                payload: interaction.customId,
+                sourceMessageId: interaction.sourceMessageId,
+            }),
+        }).catch((err) => {
+            this.#logger.warn(formatCompact({
+                op: 'discord_gateway_receive_failed',
+                target: `${conversation.kind}:${conversation.id}`,
+                error: err instanceof Error ? err.message : String(err),
+            }));
+        });
+    }
+    async #addReaction(channelId, messageId, emoji) {
+        const channel = await this.#requireClient().channels.fetch(channelId);
+        if (!channel?.isTextBased() || !channel.messages) {
+            throw new Error(`Channel ${channelId} 不是文本频道`);
+        }
+        const message = await channel.messages.fetch(messageId);
+        await message.react(emoji);
+    }
+    async #emitPlatformEvent(name, event) {
+        await this.emitPlatform(name, event).catch((error) => {
+            this.#logger.warn(formatCompact({
+                op: 'discord_platform_event_failed',
+                event: name,
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        });
+    }
+    async #sendBody(channelId, body) {
+        const channel = await this.#requireClient().channels.fetch(channelId);
+        if (!channel || !channel.isTextBased() || !channel.send) {
+            throw new Error(`Channel ${channelId} is not a text channel`);
+        }
+        const options = await toMessageCreateOptions(body);
+        const result = await channel.send(options);
+        return result.id;
+    }
+    #requireClient() {
+        if (!this.#client)
+            throw new Error('Discord client not connected');
+        return this.#client;
+    }
+}
+/** Minimal Discord REST client used when Gateway is intentionally disabled. */
+export class DiscordRestClient {
+    token;
+    fetch;
+    constructor(token, fetch = globalThis.fetch) {
+        this.token = token;
+        this.fetch = fetch;
+    }
+    async request(method, path, body) {
+        const response = await this.fetch(`${DISCORD_API}${path}`, {
+            method,
+            headers: {
+                Authorization: `Bot ${this.token}`,
+                ...(body === undefined ? {} : { 'Content-Type': 'application/json' }),
+            },
+            ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+            signal: AbortSignal.timeout(OUTBOUND_TIMEOUT_MS),
+        });
+        const text = await response.text();
+        if (!response.ok) {
+            throw new Error(`Discord API ${method} ${path} failed (${response.status}): ${text.slice(0, 200)}`);
+        }
+        return (text ? JSON.parse(text) : undefined);
+    }
+    createMessage(channelId, body) {
+        return this.request('POST', `/channels/${channelId}/messages`, body);
+    }
+    deleteMessage(channelId, messageId) {
+        return this.request('DELETE', `/channels/${channelId}/messages/${messageId}`);
+    }
+}
+export class DiscordInteractionsEndpoint extends Endpoint {
+    client;
+    #logger;
+    #options;
+    #fetch;
+    #routeReleases = [];
+    #open = false;
+    #started = false;
+    control = Object.freeze({
+        recall: (message) => this.recallMessage(message),
+    });
+    content = Object.freeze({
+        resolve: (reference, context) => resolveDiscordContent(this.#fetch, this.#options.config.token, reference, context),
+    });
+    constructor(options) {
+        super();
+        this.#logger = getAdapterLogger('discord', options.config.id);
+        this.#options = options;
+        this.#fetch = options.fetch ?? globalThis.fetch;
+        this.client = new DiscordRestClient(options.config.token, this.#fetch);
+    }
+    get isOpen() {
+        return this.#open;
+    }
+    get config() {
+        return this.#options.config;
+    }
+    async start() {
+        if (this.#started)
+            return;
+        this.#started = true;
+        this.#routeReleases.push(...registerDiscordInteractionRoutes(this.#options.http, this));
+        this.#logger.info(formatCompact({
+            op: 'connect',
+            endpoint: this.#options.config.id,
+            mode: 'interactions',
+            path: this.#options.config.interactionsPath,
+        }));
+    }
+    open() {
+        this.#open = true;
+    }
+    close() {
+        this.#open = false;
+    }
+    async stop() {
+        this.#open = false;
+        for (const release of this.#routeReleases.splice(0))
+            release();
+        this.#started = false;
+        this.#logger.debug(formatCompact({ op: 'disconnect' }));
+    }
+    async send({ conversation, payload }) {
+        const body = formatOutboundBody(payload);
+        const data = await this.client.createMessage(conversation.id, body);
+        return data.id ?? '';
+    }
+    async recallMessage(message) {
+        if (!message.id)
+            return;
+        await this.client.deleteMessage(message.conversation.id, message.id);
+    }
+    admit(msg) {
+        if (!this.#open)
+            return;
+        const conversation = discordInboundConversation(String(this.#options.id), msg);
+        void this.emit('message.receive', {
+            conversation,
+            message: { conversation, id: msg.id },
+            content: formatInboundContent(msg),
+            segments: formatInboundSegments(msg),
+            sender: {
+                id: msg.authorId,
+                name: senderDisplayName(msg) || undefined,
+                ...(resolveSenderRole(msg) ? { roles: [resolveSenderRole(msg)] } : {}),
+            },
+            endpointId: this.#options.config.id,
+            metadata: Object.freeze({
+                channelKind: msg.channelKind,
+                userId: msg.authorId,
+                guildId: msg.guildId,
+                eventType: 'application_command',
+            }),
+        }).catch((err) => {
+            this.#logger.warn(formatCompact({
+                op: 'discord_gateway_receive_failed',
+                target: `${conversation.kind}:${conversation.id}`,
+                error: err instanceof Error ? err.message : String(err),
+            }));
+        });
+    }
+    admitPlatform(event) {
+        if (!this.#open)
+            return;
+        const type = typeof event.type === 'number' ? `interaction.${event.type}` : 'interaction';
+        void this.emitPlatform(type, event).catch((error) => {
+            this.#logger.warn(formatCompact({
+                op: 'discord_platform_event_failed',
+                event: type,
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        });
+    }
+}
+async function resolveDiscordContent(fetch, token, reference, context) {
+    if (reference.kind === 'forward') {
+        return Object.freeze({ status: 'unsupported', code: 'discord_merged_forward_unavailable' });
+    }
+    if (reference.kind === 'media') {
+        return reference.media.kind === 'file'
+            ? Object.freeze({ status: 'unsupported', code: 'discord_opaque_media_unavailable' })
+            : Object.freeze({ status: 'resolved', reference, value: reference.media });
+    }
+    try {
+        context.signal.throwIfAborted();
+        const response = await fetch(`${DISCORD_API}/channels/${reference.message.conversation.id}/messages/${reference.message.id}`, { headers: { Authorization: `Bot ${token}` }, signal: context.signal });
+        if (response.status === 404)
+            return Object.freeze({ status: 'not_found', code: 'discord_message_not_found' });
+        if (response.status === 403)
+            return Object.freeze({ status: 'forbidden', code: 'discord_message_forbidden' });
+        if (!response.ok)
+            return Object.freeze({ status: 'failed', code: 'discord_message_fetch_failed' });
+        const row = await response.json();
+        const author = row.author;
+        const attachments = Array.isArray(row.attachments) ? row.attachments : [];
+        const segments = [];
+        if (typeof row.content === 'string' && row.content.trim())
+            segments.push({ type: 'text', data: { text: row.content } });
+        for (const item of attachments.slice(0, context.maxEntries)) {
+            const attachment = item;
+            if (typeof attachment.url !== 'string')
+                continue;
+            const mime = typeof attachment.content_type === 'string' ? attachment.content_type : undefined;
+            const type = mime?.startsWith('image/') ? 'image' : mime?.startsWith('audio/') ? 'audio' : mime?.startsWith('video/') ? 'video' : 'file';
+            segments.push({ type, data: { media: { kind: 'url', value: attachment.url, ...(mime ? { mime_type: mime } : {}), ...(attachment.filename ? { file_name: String(attachment.filename) } : {}), ...(typeof attachment.size === 'number' ? { size: attachment.size } : {}) } } });
+        }
+        return Object.freeze({
+            status: 'resolved',
+            reference,
+            value: Object.freeze({
+                ref: reference.message,
+                ...(author?.id ? { actor: Object.freeze({ id: String(author.id), ...(author.global_name || author.username ? { displayName: String(author.global_name ?? author.username) } : {}) }) } : {}),
+                segments: Object.freeze(segments),
+                timestamp: typeof row.timestamp === 'string' ? Date.parse(row.timestamp) : Date.now(),
+            }),
+        });
+    }
+    catch (error) {
+        if (context.signal.aborted)
+            return Object.freeze({ status: 'expired', code: 'turn_aborted' });
+        return Object.freeze({ status: 'failed', code: 'discord_content_resolution_failed', message: error instanceof Error ? error.message : String(error) });
+    }
+}
+/**
+ * Discord snowflake 是 64 位整数的字符串形式，超出 Number.MAX_SAFE_INTEGER，
+ * Number() 转换会丢精度。Console 社交面只把 group_id 当 JSON 值透传、
+ * 并以字符串回传给 listGroupMembers，因此这里保留原始字符串（仅按契约
+ * 类型声明强转），是全链路最不丢信息的方案。
+ */
+function toGroupId(id) {
+    return id;
+}
+/**
+ * DiscordGatewayEndpoint 的 EndpointManagement 语义端口（参照 qq 的工厂模式）。
+ * 数据源为 discord.js SDK 缓存：guilds.cache / guild.channels.cache / guild.members。
+ */
+export function createDiscordEndpointManagement(requireClient) {
+    return Object.freeze({
+        async listGroups() {
+            const groups = [];
+            for (const guild of requireClient().guilds.cache.values()) {
+                if (!guild?.id)
+                    continue;
+                groups.push({
+                    group_id: toGroupId(String(guild.id)),
+                    name: String(guild.name ?? guild.id),
+                });
+            }
+            return groups;
+        },
+        async listChannels() {
+            const channels = [];
+            for (const guild of requireClient().guilds.cache.values()) {
+                if (!guild?.id)
+                    continue;
+                const guildId = String(guild.id);
+                const guildName = String(guild.name ?? guildId);
+                for (const channel of guild.channels?.cache?.values() ?? []) {
+                    if (!channel?.id)
+                        continue;
+                    if (channel.type !== ChannelType.GuildText)
+                        continue;
+                    channels.push({
+                        id: String(channel.id),
+                        name: channel.name ? String(channel.name) : undefined,
+                        parent: { type: 'guild', id: guildId, name: guildName },
+                    });
+                }
+            }
+            return channels;
+        },
+        async listGroupMembers(groupId) {
+            const guild = await requireClient().guilds.fetch(groupId);
+            const members = await guild.members.fetch({ limit: 100 });
+            return [...members.values()].map((member) => ({
+                id: member.id,
+                username: member.user.username,
+                nickname: member.nickname,
+                roles: member.roles.cache.map((role) => role.id),
+                joined_at: member.joinedAt?.toISOString(),
+            }));
+        },
+    });
+}

package/lib/gateway.d.ts

@@ -0,0 +1,144 @@
+import { GatewayIntentBits, type MessageCreateOptions } from 'discord.js';
+import { type DiscordButtonInbound, type DiscordInboundMessage, type DiscordOutboundBody, type ResolvedDiscordGatewayConfig } from './protocol.js';
+export declare const DEFAULT_INTENTS: GatewayIntentBits[];
+/** Minimal client surface used by the endpoint (real discord.js or test mock). */
+export interface DiscordClientTransport {
+    login(token: string): Promise<string>;
+    destroy(): Promise<void>;
+    on(event: string, listener: (...args: unknown[]) => void): void;
+    once(event: string, listener: (...args: unknown[]) => void): void;
+    removeAllListeners(): void;
+    readonly user?: {
+        readonly id: string;
+        readonly tag?: string;
+        setActivity?(name: string, options?: {
+            type?: number;
+            url?: string;
+        }): void;
+    } | null;
+    channels: {
+        fetch(id: string): Promise<{
+            id: string;
+            type: number;
+            isTextBased(): boolean;
+            send?(options: MessageCreateOptions): Promise<{
+                id: string;
+            }>;
+            messages?: {
+                fetch(id: string): Promise<{
+                    delete(): Promise<unknown>;
+                    react(emoji: string): Promise<unknown>;
+                    reactions: {
+                        resolve(emoji: unknown): {
+                            users: {
+                                remove(userId: string): Promise<unknown>;
+                            };
+                        } | null;
+                        cache: {
+                            find(fn: (r: {
+                                emoji: {
+                                    toString(): string;
+                                    name?: string | null;
+                                    id?: string | null;
+                                };
+                            }) => boolean): {
+                                users: {
+                                    remove(userId: string): Promise<unknown>;
+                                };
+                            } | undefined;
+                        };
+                    };
+                }>;
+            };
+            threads?: {
+                create(options: Record<string, unknown>): Promise<{
+                    id: string;
+                }>;
+            };
+            availableTags?: Array<{
+                id: string;
+                name: string;
+            }>;
+        } | null>;
+    };
+    guilds: {
+        fetch(id: string): Promise<{
+            id: string;
+            name: string;
+            ownerId: string;
+            memberCount: number;
+            createdAt?: Date | null;
+            iconURL?(options?: {
+                size?: number;
+            }): string | null;
+            roles: {
+                fetch(): Promise<unknown>;
+                cache: Map<string, {
+                    id: string;
+                    name: string;
+                    hexColor: string;
+                    position: number;
+                    permissions: {
+                        bitfield: bigint;
+                    };
+                }> | {
+                    map(fn: (role: {
+                        id: string;
+                        name: string;
+                        hexColor: string;
+                        position: number;
+                        permissions: {
+                            bitfield: bigint;
+                        };
+                    }) => unknown): unknown[];
+                };
+            };
+            members: {
+                fetch(userId: string | {
+                    limit?: number;
+                }): Promise<unknown>;
+                ban(userId: string, options?: {
+                    reason?: string;
+                    deleteMessageSeconds?: number;
+                }): Promise<unknown>;
+                unban(userId: string, reason?: string): Promise<unknown>;
+            };
+        }>;
+        cache: {
+            values(): IterableIterator<{
+                id: string;
+                name: string;
+                channels: {
+                    cache: {
+                        values(): IterableIterator<{
+                            id: string;
+                            name?: string;
+                            type: number;
+                        }>;
+                    };
+                };
+            }>;
+        };
+    };
+}
+export type CreateDiscordClient = (intents: readonly number[]) => DiscordClientTransport;
+export declare function defaultCreateClient(intents: readonly number[]): DiscordClientTransport;
+export declare function resolveSenderRole(msg: DiscordInboundMessage): string | undefined;
+export declare function normalizeDiscordMessage(raw: unknown): DiscordInboundMessage | null;
+export declare function toMessageCreateOptions(body: DiscordOutboundBody): Promise<MessageCreateOptions>;
+export interface DiscordGatewayConnectHandlers {
+    onPlatformEvent(name: string, event: unknown): void;
+    onMessage(msg: DiscordInboundMessage): void;
+    onButton(interaction: DiscordButtonInbound): void;
+    onGuildMemberAdd?(member: {
+        guildId: string;
+        userId: string;
+        userName?: string;
+    }): void;
+    onGuildMemberRemove?(member: {
+        guildId: string;
+        userId: string;
+        userName?: string;
+    }): void;
+}
+export declare function connectDiscordGatewayClient(client: DiscordClientTransport, config: ResolvedDiscordGatewayConfig, handlers: DiscordGatewayConnectHandlers): Promise<void>;