@elizaos/plugin-discord 1.3.7 → 2.0.0-alpha.1

package/dist/index.d.ts

@@ -1,942 +1,2 @@
-import { IAgentRuntime, World, UUID, Room, ChannelType, Entity, Character, Media, Memory, Service, TargetInfo, Content, Plugin } from '@elizaos/core';
-import { Client, Channel, Message, VoiceState, BaseGuildVoiceChannel, Guild, Role } from 'discord.js';
-import { VoiceConnection, AudioPlayer } from '@discordjs/voice';
-import { EventEmitter } from 'node:events';
-import { Readable } from 'node:stream';
-
-declare const DISCORD_SERVICE_NAME = "discord";
-
-/**
- * Runtime compatibility layer for old/new core.
- *
- * Automatically adds serverId when messageServerId is provided,
- * making plugin code work with both core versions unchanged.
- *
- * Old core expects: serverId (string)
- * New core expects: messageServerId (UUID)
- *
- * NOTE: UUID function usage for Discord IDs:
- * - `stringToUuid(str)` - CONVERTS any string to a deterministic UUID by hashing.
- *   Use this for Discord snowflake IDs (always succeeds, same input = same output).
- * - `asUUID(str)` - VALIDATES that string is already a valid UUID format.
- *   Throws if not a valid UUID. Only use when input is already a UUID.
- *
- * REMOVAL: Delete this file and remove createCompatRuntime() call in service.ts
- */
-
-/**
- * Extended types that support messageServerId for cross-core compatibility.
- * These allow TypeScript to accept messageServerId in object literals.
- */
-type WorldCompat = Omit<World, 'serverId'> & {
-    serverId?: string;
-    messageServerId?: UUID;
-};
-type RoomCompat = Omit<Room, 'serverId'> & {
-    serverId?: string;
-    messageServerId?: UUID;
-};
-interface EnsureConnectionParams {
-    entityId: UUID;
-    roomId: UUID;
-    userName?: string;
-    name?: string;
-    worldName?: string;
-    source?: string;
-    channelId?: string;
-    serverId?: string;
-    messageServerId?: UUID;
-    type?: ChannelType | string;
-    worldId: UUID;
-    userId?: UUID;
-    metadata?: Record<string, unknown>;
-}
-/**
- * Extended runtime interface that accepts messageServerId in method parameters.
- */
-interface ICompatRuntime extends Omit<IAgentRuntime, 'ensureWorldExists' | 'ensureRoomExists' | 'ensureConnection' | 'ensureConnections'> {
-    ensureWorldExists(world: WorldCompat): Promise<void>;
-    ensureRoomExists(room: RoomCompat): Promise<void>;
-    ensureConnection(params: EnsureConnectionParams): Promise<void>;
-    ensureConnections(entities: Entity[], rooms: RoomCompat[], source: string, world: WorldCompat): Promise<void>;
-}
-
-/**
- * Discord-specific event types
- */
-declare enum DiscordEventTypes {
-    MESSAGE_RECEIVED = "DISCORD_MESSAGE_RECEIVED",
-    MESSAGE_SENT = "DISCORD_MESSAGE_SENT",
-    SLASH_COMMAND = "DISCORD_SLASH_COMMAND",
-    MODAL_SUBMIT = "DISCORD_MODAL_SUBMIT",
-    REACTION_RECEIVED = "DISCORD_REACTION_RECEIVED",
-    REACTION_REMOVED = "DISCORD_REACTION_REMOVED",
-    WORLD_JOINED = "DISCORD_WORLD_JOINED",
-    WORLD_CONNECTED = "DISCORD_SERVER_CONNECTED",
-    ENTITY_JOINED = "DISCORD_USER_JOINED",
-    ENTITY_LEFT = "DISCORD_USER_LEFT",
-    VOICE_STATE_CHANGED = "DISCORD_VOICE_STATE_CHANGED",
-    CHANNEL_PERMISSIONS_CHANGED = "DISCORD_CHANNEL_PERMISSIONS_CHANGED",
-    ROLE_PERMISSIONS_CHANGED = "DISCORD_ROLE_PERMISSIONS_CHANGED",
-    MEMBER_ROLES_CHANGED = "DISCORD_MEMBER_ROLES_CHANGED",
-    ROLE_CREATED = "DISCORD_ROLE_CREATED",
-    ROLE_DELETED = "DISCORD_ROLE_DELETED"
-}
-/**
- * Permission state in an overwrite or role
- */
-type PermissionState = "ALLOW" | "DENY" | "NEUTRAL";
-/**
- * A single permission change
- */
-interface PermissionDiff {
-    /** The permission name (e.g., 'ManageMessages', 'Administrator') */
-    permission: string;
-    /** Previous state */
-    oldState: PermissionState;
-    /** New state */
-    newState: PermissionState;
-}
-/**
- * Information about who made a change, from audit logs
- */
-interface AuditInfo {
-    /** Discord user ID of the executor */
-    executorId: string;
-    /** Discord username#discriminator or username of the executor */
-    executorTag: string;
-    /** Reason provided for the action, if any */
-    reason: string | null;
-}
-/**
- * Minimal runtime interface for permission payloads.
- * Using a minimal interface avoids version mismatches across packages.
- */
-interface PermissionPayloadRuntime {
-    getService(name: string): unknown;
-    getSetting(key: string): unknown;
-    logger: {
-        debug(msg: string): void;
-        info(msg: string): void;
-        warn(msg: string): void;
-        error(msg: string): void;
-    };
-}
-/**
- * Payload for DISCORD_CHANNEL_PERMISSIONS_CHANGED event
- * Emitted when channel permission overwrites are created, updated, or deleted
- */
-interface ChannelPermissionsChangedPayload {
-    /** Runtime instance */
-    runtime: PermissionPayloadRuntime;
-    /** Guild information */
-    guild: {
-        id: string;
-        name: string;
-    };
-    /** Channel where permissions changed */
-    channel: {
-        id: string;
-        name: string;
-    };
-    /** Target of the permission overwrite (role or user) */
-    target: {
-        type: "role" | "user";
-        id: string;
-        name: string;
-    };
-    /** What happened to the overwrite */
-    action: "CREATE" | "UPDATE" | "DELETE";
-    /** List of permission changes */
-    changes: PermissionDiff[];
-    /** Audit log info (null if unavailable) */
-    audit: AuditInfo | null;
-}
-/**
- * Payload for DISCORD_ROLE_PERMISSIONS_CHANGED event
- * Emitted when a role's permissions are modified
- */
-interface RolePermissionsChangedPayload {
-    /** Runtime instance */
-    runtime: PermissionPayloadRuntime;
-    /** Guild information */
-    guild: {
-        id: string;
-        name: string;
-    };
-    /** Role that was modified */
-    role: {
-        id: string;
-        name: string;
-    };
-    /** List of permission changes */
-    changes: PermissionDiff[];
-    /** Audit log info (null if unavailable) */
-    audit: AuditInfo | null;
-}
-/**
- * Payload for DISCORD_MEMBER_ROLES_CHANGED event
- * Emitted when roles are added or removed from a member
- */
-interface MemberRolesChangedPayload {
-    /** Runtime instance */
-    runtime: PermissionPayloadRuntime;
-    /** Guild information */
-    guild: {
-        id: string;
-        name: string;
-    };
-    /** Member whose roles changed */
-    member: {
-        id: string;
-        tag: string;
-    };
-    /** Roles that were added */
-    added: Array<{
-        id: string;
-        name: string;
-        permissions: string[];
-    }>;
-    /** Roles that were removed */
-    removed: Array<{
-        id: string;
-        name: string;
-        permissions: string[];
-    }>;
-    /** Audit log info (null if unavailable) */
-    audit: AuditInfo | null;
-}
-/**
- * Payload for DISCORD_ROLE_CREATED and DISCORD_ROLE_DELETED events
- */
-interface RoleLifecyclePayload {
-    /** Runtime instance */
-    runtime: PermissionPayloadRuntime;
-    /** Guild information */
-    guild: {
-        id: string;
-        name: string;
-    };
-    /** Role that was created or deleted */
-    role: {
-        id: string;
-        name: string;
-        permissions: string[];
-    };
-    /** Audit log info (null if unavailable) */
-    audit: AuditInfo | null;
-}
-/**
- * Interface representing a Discord service.
- *
- * @typedef {Object} IDiscordService
- * @property {DiscordJsClient} client - The Discord client object.
- * @property {Character} character - The character object.
- */
-interface IDiscordService {
-    client: Client | null;
-    character: Character;
-    getChannelType: (channel: Channel) => Promise<ChannelType>;
-    buildMemoryFromMessage: (message: Message, options?: {
-        processedContent?: string;
-        processedAttachments?: Media[];
-        extraContent?: Record<string, any>;
-        extraMetadata?: Record<string, any>;
-    }) => Promise<Memory | null>;
-}
-/**
- * Batch handler for processing messages as they arrive during history fetch
- * @returns false to stop fetching early, void/true to continue
- */
-type BatchHandler = (batch: Memory[], stats: {
-    page: number;
-    totalFetched: number;
-    totalStored: number;
-}) => Promise<boolean | void> | boolean | void;
-/**
- * Options for fetching channel history
- */
-interface ChannelHistoryOptions {
-    /** Maximum number of messages to fetch (default: unlimited) */
-    limit?: number;
-    /** Force re-fetch, ignoring spider state */
-    force?: boolean;
-    /** Callback to process each batch of messages as they arrive */
-    onBatch?: BatchHandler;
-    /** Start fetching before this message ID */
-    before?: string;
-    /** Start fetching after this message ID (for catching up) */
-    after?: string;
-}
-/**
- * Result from fetching channel history
- */
-interface ChannelHistoryResult {
-    /** Fetched messages (empty if onBatch was used) */
-    messages: Memory[];
-    /** Statistics about the fetch operation */
-    stats: {
-        /** Total messages fetched from Discord */
-        fetched: number;
-        /** Total messages stored/processed */
-        stored: number;
-        /** Number of pages fetched */
-        pages: number;
-        /** Whether the channel is now fully backfilled */
-        fullyBackfilled: boolean;
-    };
-}
-
-/**
- * Class representing a Message Manager for handling Discord messages.
- */
-declare class MessageManager {
-    private client;
-    private runtime;
-    private attachmentManager;
-    private getChannelType;
-    private discordSettings;
-    private discordService;
-    /**
-     * Constructor for a new instance of MessageManager.
-     * @param {IDiscordService} discordService - The Discord service instance.
-     * @param {ICompatRuntime} runtime - The agent runtime instance (with cross-core compat).
-     * @throws {Error} If the Discord client is not initialized
-     */
-    constructor(discordService: IDiscordService, runtime: ICompatRuntime);
-    /**
-     * Handles incoming Discord messages and processes them accordingly.
-     *
-     * @param {DiscordMessage} message - The Discord message to be handled
-     */
-    handleMessage(message: Message): Promise<void>;
-    /**
-     * Processes the message content, mentions, code blocks, attachments, and URLs to generate
-     * processed content and media attachments.
-     *
-     * @param {DiscordMessage} message The message to process
-     * @returns {Promise<{ processedContent: string; attachments: Media[] }>} Processed content and media attachments
-     */
-    processMessage(message: Message): Promise<{
-        processedContent: string;
-        attachments: Media[];
-    }>;
-    /**
-     * Asynchronously fetches the bot's username and discriminator from Discord API.
-     *
-     * @param {string} botToken The token of the bot to authenticate the request
-     * @returns {Promise<string>} A promise that resolves with the bot's username and discriminator
-     * @throws {Error} If there is an error while fetching the bot details
-     */
-    fetchBotName(botToken: string): Promise<string>;
-}
-
-/**
- * Class representing a VoiceManager that extends EventEmitter.
- * @extends EventEmitter
- */
-declare class VoiceManager extends EventEmitter {
-    private processingVoice;
-    private transcriptionTimeout;
-    private userStates;
-    private activeAudioPlayer;
-    private client;
-    private runtime;
-    private streams;
-    private connections;
-    private activeMonitors;
-    private ready;
-    /**
-     * Constructor for initializing a new instance of the class.
-     *
-     * @param {DiscordService} service - The Discord service to use.
-     * @param {ICompatRuntime} runtime - The runtime for the agent (with cross-core compat).
-     */
-    constructor(service: DiscordService, runtime: ICompatRuntime);
-    /**
-     * Asynchronously retrieves the type of the channel.
-     * @param {Channel} channel - The channel to get the type for.
-     * @returns {Promise<ChannelType>} The type of the channel.
-     */
-    getChannelType(channel: Channel): Promise<ChannelType>;
-    /**
-     * Set the ready status of the VoiceManager.
-     * @param {boolean} status - The status to set.
-     */
-    private setReady;
-    /**
-     * Check if the object is ready.
-     *
-     * @returns {boolean} True if the object is ready, false otherwise.
-     */
-    isReady(): boolean;
-    /**
-     * Handle voice state update event.
-     * @param {VoiceState} oldState - The old voice state of the member.
-     * @param {VoiceState} newState - The new voice state of the member.
-     * @returns {void}
-     */
-    handleVoiceStateUpdate(oldState: VoiceState, newState: VoiceState): Promise<void>;
-    /**
-     * Joins a voice channel and sets up the necessary connection and event listeners.
-     * @param {BaseGuildVoiceChannel} channel - The voice channel to join
-     */
-    joinChannel(channel: BaseGuildVoiceChannel): Promise<void>;
-    /**
-     * Retrieves the voice connection for a given guild ID.
-     * @param {string} guildId - The ID of the guild to get the voice connection for.
-     * @returns {VoiceConnection | undefined} The voice connection for the specified guild ID, or undefined if not found.
-     */
-    getVoiceConnection(guildId: string): VoiceConnection | undefined;
-    /**
-     * Monitor a member's audio stream for volume activity and speaking thresholds.
-     *
-     * @param {GuildMember} member - The member whose audio stream is being monitored.
-     * @param {BaseGuildVoiceChannel} channel - The voice channel in which the member is connected.
-     */
-    private monitorMember;
-    /**
-     * Leaves the specified voice channel and stops monitoring all members in that channel.
-     * If there is an active connection in the channel, it will be destroyed.
-     *
-     * @param {BaseGuildVoiceChannel} channel - The voice channel to leave.
-     */
-    leaveChannel(channel: BaseGuildVoiceChannel): void;
-    /**
-     * Stop monitoring a specific member by their member ID.
-     * @param {string} memberId - The ID of the member to stop monitoring.
-     */
-    stopMonitoringMember(memberId: string): void;
-    /**
-     * Asynchronously debounces the process transcription function to prevent rapid execution.
-     *
-     * @param {UUID} entityId - The ID of the entity related to the transcription.
-     * @param {string} name - The name of the entity for transcription.
-     * @param {string} userName - The username of the user initiating the transcription.
-     * @param {BaseGuildVoiceChannel} channel - The voice channel where the transcription is happening.
-     */
-    debouncedProcessTranscription(entityId: UUID, name: string, userName: string, channel: BaseGuildVoiceChannel): Promise<void>;
-    /**
-     * Handle user audio stream for monitoring purposes.
-     *
-     * @param {UUID} userId - The unique identifier of the user.
-     * @param {string} name - The name of the user.
-     * @param {string} userName - The username of the user.
-     * @param {BaseGuildVoiceChannel} channel - The voice channel the user is in.
-     * @param {Readable} audioStream - The audio stream to monitor.
-     */
-    handleUserStream(entityId: UUID, name: string, userName: string, channel: BaseGuildVoiceChannel, audioStream: Readable): Promise<void>;
-    /**
-     * Process the transcription of audio data for a user.
-     *
-     * @param {UUID} entityId - The unique ID of the user entity.
-     * @param {string} channelId - The ID of the channel where the transcription is taking place.
-     * @param {BaseGuildVoiceChannel} channel - The voice channel where the user is speaking.
-     * @param {string} name - The name of the user.
-     * @param {string} userName - The username of the user.
-     * @returns {Promise<void>}
-     */
-    private processTranscription;
-    /**
-     * Handles a voice message received in a Discord channel.
-     *
-     * @param {string} message - The message content.
-     * @param {UUID} entityId - The entity ID associated with the message.
-     * @param {string} channelId - The ID of the Discord channel where the message was received.
-     * @param {BaseGuildVoiceChannel} channel - The Discord channel where the message was received.
-     * @param {string} name - The name associated with the message.
-     * @param {string} userName - The user name associated with the message.
-     * @returns {Promise<{text: string, actions: string[]}>} Object containing the resulting text and actions.
-     */
-    private handleMessage;
-    /**
-     * Asynchronously converts an Opus audio Buffer to a WAV audio Buffer.
-     *
-     * @param {Buffer} pcmBuffer - The Opus audio Buffer to convert to WAV.
-     * @returns {Promise<Buffer>} A Promise that resolves with the converted WAV audio Buffer.
-     */
-    private convertOpusToWav;
-    /**
-     * Scans the given Discord guild to select a suitable voice channel to join.
-     *
-     * @param {Guild} guild The Discord guild to scan for voice channels.
-     */
-    scanGuild(guild: Guild): Promise<void>;
-    /**
-     * Play an audio stream for a given entity ID.
-     *
-     * @param {UUID} entityId - The ID of the entity to play the audio for.
-     * @param {Readable} audioStream - The audio stream to play.
-     * @returns {void}
-     */
-    playAudioStream(entityId: UUID, audioStream: Readable): Promise<void>;
-    /**
-     * Cleans up the provided audio player by stopping it, removing all listeners,
-     * and resetting the active audio player if it matches the provided player.
-     *
-     * @param {AudioPlayer} audioPlayer - The audio player to be cleaned up.
-     */
-    cleanupAudioPlayer(audioPlayer: AudioPlayer | null): void;
-    /**
-     * Asynchronously handles the join channel command in an interaction.
-     *
-     * @param {any} interaction - The interaction object representing the user's input.
-     * @returns {Promise<void>} - A promise that resolves once the join channel command is handled.
-     */
-    handleJoinChannelCommand(interaction: any): Promise<void>;
-    /**
-     * Handles the leave channel command by destroying the voice connection if it exists.
-     *
-     * @param {any} interaction The interaction object representing the command invocation.
-     * @returns {void}
-     */
-    handleLeaveChannelCommand(interaction: any): Promise<void>;
-}
-
-/**
- * DiscordService class representing a service for interacting with Discord.
- * @extends Service
- * @implements IDiscordService
- * @property {string} serviceType - The type of service, set to DISCORD_SERVICE_NAME.
- * @property {string} capabilityDescription - A description of the service's capabilities.
- * @property {DiscordJsClient} client - The DiscordJsClient used for communication.
- * @property {Character} character - The character associated with the service.
- * @property {MessageManager} messageManager - The manager for handling messages.
- * @property {VoiceManager} voiceManager - The manager for handling voice communication.
- */
-declare class DiscordService extends Service implements IDiscordService {
-    protected runtime: ICompatRuntime;
-    static serviceType: string;
-    capabilityDescription: string;
-    client: Client | null;
-    character: Character;
-    messageManager?: MessageManager;
-    voiceManager?: VoiceManager;
-    private discordSettings;
-    private userSelections;
-    private timeouts;
-    clientReadyPromise: Promise<void> | null;
-    private slashCommands;
-    private commandRegistrationQueue;
-    /**
-     * Slash command names that should bypass allowed channel restrictions.
-     */
-    private allowAllSlashCommands;
-    /**
-     * List of allowed channel IDs (parsed from CHANNEL_IDS env var).
-     * If undefined, all channels are allowed.
-     */
-    private allowedChannelIds?;
-    /**
-     * Set of dynamically added channel IDs through joinChannel action.
-     * These are merged with allowedChannelIds for runtime channel management.
-     */
-    private dynamicChannelIds;
-    /**
-     * Constructor for Discord client.
-     * Initializes the Discord client with specified intents and partials,
-     * sets up event listeners, and ensures all servers exist.
-     *
-     * @param {IAgentRuntime} runtime - The AgentRuntime instance
-     */
-    constructor(runtime: IAgentRuntime);
-    static start(runtime: IAgentRuntime): Promise<DiscordService>;
-    /**
-     * The SendHandlerFunction implementation for Discord.
-     * @param {IAgentRuntime} runtime - The runtime instance.
-     * @param {TargetInfo} target - The target information for the message.
-     * @param {Content} content - The content of the message to send.
-     * @returns {Promise<void>} A promise that resolves when the message is sent or rejects on error.
-     * @throws {Error} If the client is not ready, target is invalid, or sending fails.
-     */
-    handleSendMessage(runtime: IAgentRuntime, target: TargetInfo, content: Content): Promise<void>;
-    /**
-     * Set up event listeners for the client.
-     * @private
-     */
-    private setupEventListeners;
-    /**
-     * Handles the event when a new member joins a guild.
-     *
-     * **Event Design Note:**
-     * We intentionally do NOT emit the standardized `EventType.ENTITY_JOINED` here.
-     * In ElizaOS's abstraction model:
-     * - A Discord "guild" maps to a "world" (the server/community)
-     * - A Discord "channel" maps to a "room" (a specific conversation space)
-     *
-     * `EventType.ENTITY_JOINED` requires a `roomId` because the bootstrap plugin's
-     * handler calls `syncSingleUser()` to sync the entity to a specific room. When
-     * a member joins a guild, they've joined the "world" but haven't joined any
-     * specific "room" yet - they're just a potential participant.
-     *
-     * The entity will be properly synced to rooms when they first interact:
-     * - First message in a channel → message handler calls `ensureConnection()`
-     * - Joining a voice channel → voice handler syncs them to that room
-     *
-     * We still emit the Discord-specific `DiscordEventTypes.ENTITY_JOINED` so that
-     * Discord-aware plugins can react to guild member joins (e.g., welcome messages,
-     * role assignment, moderation checks).
-     *
-     * @param {GuildMember} member - The GuildMember object representing the new member.
-     * @returns {Promise<void>} - A Promise that resolves once the event handling is complete.
-     * @private
-     */
-    private handleGuildMemberAdd;
-    /**
-     * Registers slash commands with Discord.
-     *
-     * This method uses a hybrid permission system that combines:
-     * 1. Discord's native permission features (default_member_permissions, contexts)
-     * 2. ElizaOS channel whitelist bypass (bypassChannelWhitelist flag)
-     * 3. Custom validation functions (validator callback)
-     *
-     * ## Design Decisions
-     *
-     * ### Why Hybrid Approach?
-     * - Discord's native permissions are powerful but limited to role-based access
-     * - ElizaOS needs programmatic control for channel restrictions and custom logic
-     * - Combining both gives developers the best of both worlds
-     *
-     * ### Why Transform Simple Flags?
-     * - Developer experience: `guildOnly: true` is clearer than `contexts: [0]`
-     * - Abstraction: Shields developers from Discord API changes
-     * - Sensible defaults: Zero config should "just work"
-     *
-     * ### Why Three Registration Categories?
-     *
-     * Commands are categorized based on where they should be available:
-     *
-     * 1. **Global commands** (no guildOnly, no guildIds):
-     *    - Registered globally via `application.commands.set()` for DM access
-     *    - ALSO registered per-guild for instant availability in guilds
-     *    - Guild version overrides global (no duplicates shown in Discord)
-     *    - Best of both worlds: instant in guilds + works in DMs
-     *
-     * 2. **Guild-only commands** (guildOnly: true or contexts: [0]):
-     *    - Registered per-guild via `application.commands.set(cmds, guildId)`
-     *    - NOT available in DMs (correct behavior)
-     *    - Instant availability in guilds
-     *    - New guilds get commands via guildCreate event
-     *
-     * 3. **Targeted commands** (has guildIds array):
-     *    - Registered only to specified guilds via `.create()` or `.edit()`
-     *    - Useful for testing or server-specific features
-     *    - Instant updates
-     *
-     * ### Why Register Global Commands Both Globally AND Per-Guild?
-     * - Global registration alone takes up to 1 hour to propagate (Discord limitation)
-     * - Per-guild registration gives instant availability
-     * - Guild commands override global ones in that guild (no duplicates)
-     * - Global registration still needed for DM access (no guild context in DMs)
-     *
-     * ### Why Not Register Everything Per-Guild Only?
-     * - Commands that work in DMs MUST be registered globally
-     * - There's no guild context in DMs, so per-guild commands don't appear there
-     *
-     * @param commands - Array of slash commands to register
-     * @returns Promise that resolves when registration is complete
-     * @private
-     */
-    private registerSlashCommands;
-    /**
-     * Transforms an ElizaOS slash command to Discord API format.
-     * This bridges our developer-friendly API with Discord's native requirements.
-     * @param {DiscordSlashCommand} cmd - The ElizaOS command definition
-     * @returns {object} Discord API compatible command object
-     * @private
-     */
-    private transformCommandToDiscordApi;
-    /**
-     * Checks if a command is guild-only (shouldn't appear in DMs).
-     *
-     * A command is considered guild-only if:
-     * - `contexts: [0]` is set (Discord's native format, where 0 = Guild only)
-     * - `guildOnly: true` is set AND no contexts override is provided
-     *
-     * Note: `contexts` takes precedence over `guildOnly` to be consistent with
-     * `transformCommandToDiscordApi`. This means { guildOnly: true, contexts: [0, 1] }
-     * will correctly enable DM access (not be treated as guild-only).
-     *
-     * @param {DiscordSlashCommand} cmd - The command to check
-     * @returns {boolean} True if the command should only be available in guilds
-     * @private
-     */
-    private isGuildOnlyCommand;
-    /**
-     * Handles the event when the bot joins a guild. It logs the guild name, fetches additional information about the guild, scans the guild for voice data, creates standardized world data structure, generates unique IDs, and emits events to the runtime.
-     * @param {Guild} guild - The guild that the bot has joined.
-     * @returns {Promise<void>} A promise that resolves when the guild creation is handled.
-     * @private
-     */
-    private handleGuildCreate;
-    /**
-     * Handles interactions created by the user, specifically commands and message components.
-     * @param {Interaction} interaction - The interaction object received.
-     * @returns {Promise<void>} A promise that resolves when the interaction is handled.
-     * @private
-     */
-    private handleInteractionCreate;
-    /**
-     * Builds a standardized list of rooms from Discord guild channels.
-     *
-     * @param {Guild} guild The guild to build rooms for.
-     * @param {UUID} _worldId The ID of the world to associate with the rooms (currently unused in favor of direct channel to room mapping).
-     * @returns {Promise<any[]>} An array of standardized room objects.
-     * @private
-     */
-    private buildStandardizedRooms;
-    /**
-     * Builds a standardized list of users (entities) from Discord guild members.
-     * Implements different strategies based on guild size for performance.
-     *
-     * @param {Guild} guild - The guild from which to build the user list.
-     * @returns {Promise<Entity[]>} A promise that resolves with an array of standardized entity objects.
-     * @private
-     */
-    private buildStandardizedUsers;
-    /**
-     * Handles tasks to be performed once the Discord client is fully ready and connected.
-     * This includes fetching guilds, scanning for voice data, and emitting connection events.
-     * @private
-     * @returns {Promise<void>} A promise that resolves when all on-ready tasks are completed.
-     */
-    private onReady;
-    /**
-     * Registers send handlers for the Discord service instance.
-     * This allows the runtime to correctly dispatch messages to this service.
-     * @param {IAgentRuntime} runtime - The agent runtime instance.
-     * @param {DiscordService} serviceInstance - The instance of the DiscordService.
-     * @static
-     */
-    static registerSendHandlers(runtime: IAgentRuntime, serviceInstance: DiscordService): void;
-    /**
-     * Fetches all members who have access to a specific text channel.
-     *
-     * @param {string} channelId - The Discord ID of the text channel.
-     * @param {boolean} [useCache=true] - Whether to prioritize cached data. Defaults to true.
-     * @returns {Promise<Array<{id: string, username: string, displayName: string}>>} A promise that resolves with an array of channel member objects, each containing id, username, and displayName.
-     */
-    getTextChannelMembers(channelId: string, useCache?: boolean): Promise<Array<{
-        id: string;
-        username: string;
-        displayName: string;
-    }>>;
-    /**
-     * Fetches the topic/description of a Discord text channel.
-     *
-     * WHY THIS METHOD EXISTS:
-     * =======================
-     * Room metadata contains topic from initial sync, but channel topics can change.
-     * This method lets plugins fetch FRESH topic data directly from Discord API.
-     *
-     * Used by plugin-content-seeder to get authoritative topic data for discussion seeding.
-     *
-     * WHY NOT JUST USE METADATA:
-     * Room.metadata.topic is set at sync time and may be stale if the Discord admin
-     * updates the channel topic. For plugins that care about freshness, this method
-     * provides a way to get current data.
-     *
-     * TRADEOFF: This makes an API call, so it's slower than reading metadata.
-     * Use metadata for most cases, this method when freshness matters.
-     *
-     * @param {string} channelId - The Discord ID of the text channel.
-     * @returns {Promise<string | null>} The channel topic, or null if not available.
-     */
-    getChannelTopic(channelId: string): Promise<string | null>;
-    /**
-     * Generic handler for reaction events (add/remove).
-     * @private
-     */
-    private handleReaction;
-    /**
-     * Handles reaction addition.
-     * @private
-     */
-    private handleReactionAdd;
-    /**
-     * Handles reaction removal.
-     * @private
-     */
-    private handleReactionRemove;
-    /**
-     * Checks if a channel ID is allowed based on both env config and dynamic additions.
-     * @param {string} channelId - The channel ID to check
-     * @returns {boolean} Whether the channel is allowed
-     */
-    isChannelAllowed(channelId: string): boolean;
-    /**
-     * Adds a channel to the dynamic allowed list.
-     * @param {string} channelId - The channel ID to add
-     * @returns {boolean} Whether the channel was successfully added
-     */
-    addAllowedChannel(channelId: string): boolean;
-    /**
-     * Removes a channel from the dynamic allowed list.
-     * @param {string} channelId - The channel ID to remove
-     * @returns {boolean} Whether the channel was in the list and removed
-     */
-    removeAllowedChannel(channelId: string): boolean;
-    /**
-     * Gets the list of all allowed channels (env + dynamic).
-     * @returns {string[]} Array of allowed channel IDs
-     */
-    getAllowedChannels(): string[];
-    /**
-     * Type guard to check if a channel is a guild text-based channel
-     * @private
-     */
-    private isGuildTextBasedChannel;
-    /**
-     * Helper to delay execution
-     * @private
-     */
-    private delay;
-    /**
-     * Get spider state for a channel from the database
-     * @private
-     */
-    private getSpiderState;
-    /**
-     * Save spider state for a channel to the database
-     * @private
-     */
-    private saveSpiderState;
-    /**
-     * Fetches and persists message history from a Discord channel.
-     * Supports pagination, state tracking, and streaming via callback.
-     *
-     * Persistence behavior:
-     * - When `onBatch` callback is NOT provided: Messages are automatically persisted
-     *   to the database and accumulated in the returned `messages` array.
-     * - When `onBatch` callback IS provided: Messages are passed to the callback and
-     *   the caller is responsible for persistence. This allows for custom handling.
-     *
-     * @param {string} channelId - The Discord channel ID to fetch from
-     * @param {ChannelHistoryOptions} options - Options for the fetch operation
-     * @returns {Promise<ChannelHistoryResult>} The result with messages and stats
-     */
-    fetchChannelHistory(channelId: string, options?: ChannelHistoryOptions): Promise<ChannelHistoryResult>;
-    /**
-     * Builds a Memory object from a Discord Message.
-     * This is a reusable helper for converting Discord messages to ElizaOS Memory format.
-     *
-     * @param {Message} message - The Discord message to convert
-     * @param {Object} options - Optional parameters
-     * @param {string} options.processedContent - Pre-processed text content (if already processed, to avoid double-processing)
-     * @param {Media[]} options.processedAttachments - Pre-processed attachments (if already processed)
-     * @param {Object} options.extraContent - Additional content fields to merge into the memory content
-     * @param {Object} options.extraMetadata - Additional metadata fields to merge into the memory metadata
-     * @returns {Promise<Memory | null>} The Memory object, or null if the message is invalid
-     */
-    buildMemoryFromMessage(message: Message, options?: {
-        processedContent?: string;
-        processedAttachments?: Media[];
-        extraContent?: Record<string, any>;
-        extraMetadata?: Record<string, any>;
-    }): Promise<Memory | null>;
-    /**
-     * Ensures entity connections exist for a batch of Discord messages using batch API.
-     * This should be called before persisting memories to avoid FK constraint failures.
-     *
-     * @param {Message[]} messages - The Discord messages to ensure connections for
-     * @param {Set<string>} ensuredEntityIds - Optional set of already-ensured entity IDs (for caching across batches)
-     * @returns {Promise<void>}
-     */
-    private ensureConnectionsForMessages;
-    /**
-     * Stops the Discord service and cleans up resources.
-     * Implements the abstract method from the Service class.
-     */
-    stop(): Promise<void>;
-    /**
-     * Asynchronously retrieves the type of a given channel.
-     *
-     * @param {Channel} channel - The channel for which to determine the type.
-     * @returns {Promise<ChannelType>} A Promise that resolves with the type of the channel.
-     */
-    getChannelType(channel: Channel): Promise<ChannelType>;
-}
-
-/**
- * Permissions that indicate moderation/admin capabilities.
- * Changes to these permissions are considered elevated and worth tracking.
- */
-declare const ELEVATED_PERMISSIONS: readonly ["Administrator", "ManageGuild", "ManageChannels", "ManageRoles", "KickMembers", "BanMembers", "ModerateMembers", "ManageMessages", "ManageWebhooks", "ManageNicknames", "MuteMembers", "DeafenMembers", "MoveMembers", "ManageEvents", "ManageThreads"];
-/**
- * Check if a role has any elevated (moderation/admin) permissions
- */
-declare function isElevatedRole(role: Role): boolean;
-/**
- * Check if an array of permission names contains any elevated permissions
- */
-declare function hasElevatedPermissions(permissions: string[]): boolean;
-
-/**
- * Permission tiers as numbers for URL generation.
- *
- * Matrix (3x2):
- * |            | No Voice         | With Voice            |
- * |------------|------------------|-----------------------|
- * | Basic      | BASIC            | BASIC_VOICE           |
- * | Moderator  | MODERATOR        | MODERATOR_VOICE       |
- * | Admin      | ADMIN            | ADMIN_VOICE           |
- *
- * Note: BigInt permissions are converted to Number for URL compatibility.
- * This is safe while Discord permissions stay below bit position 53
- * (Number.MAX_SAFE_INTEGER ≈ 9 quadrillion). Current max bit is ~46.
- */
-declare const DiscordPermissionTiers: {
-    /** Basic text-only permissions (no moderation, no voice) */
-    readonly BASIC: number;
-    /** Basic + voice permissions (no moderation) */
-    readonly BASIC_VOICE: number;
-    /** Moderator permissions (text + moderation, no voice) */
-    readonly MODERATOR: number;
-    /** Moderator + voice permissions */
-    readonly MODERATOR_VOICE: number;
-    /** Admin permissions (text + moderation + server management, no voice) */
-    readonly ADMIN: number;
-    /** Admin + voice permissions (full permissions) */
-    readonly ADMIN_VOICE: number;
-    /** @deprecated Use MODERATOR_VOICE instead */
-    readonly FULL: number;
-};
-type DiscordPermissionTier = keyof typeof DiscordPermissionTiers;
-/**
- * Generate a Discord OAuth2 invite URL for the bot.
- */
-declare function generateInviteUrl(applicationId: string, tier?: DiscordPermissionTier): string;
-/**
- * Permission values for all tiers (for compact display).
- */
-interface DiscordPermissionValues {
-    basic: number;
-    basicVoice: number;
-    moderator: number;
-    moderatorVoice: number;
-    admin: number;
-    adminVoice: number;
-}
-/**
- * Get all permission values for the 3x2 tier matrix.
- */
-declare function getPermissionValues(): DiscordPermissionValues;
-/**
- * Invite URLs organized by tier for display.
- */
-interface DiscordInviteUrls {
-    basic: string;
-    basicVoice: string;
-    moderator: string;
-    moderatorVoice: string;
-    admin: string;
-    adminVoice: string;
-}
-/**
- * Generate all tier invite URLs for display.
- */
-declare function generateAllInviteUrls(applicationId: string): DiscordInviteUrls;
-
-declare const discordPlugin: Plugin;
-
-export { type AuditInfo, type ChannelPermissionsChangedPayload, DISCORD_SERVICE_NAME, DiscordEventTypes, type DiscordPermissionTier, DiscordPermissionTiers, type DiscordPermissionValues, DiscordService, ELEVATED_PERMISSIONS, DiscordService as IDiscordService, type MemberRolesChangedPayload, type PermissionDiff, type PermissionPayloadRuntime, type PermissionState, type RoleLifecyclePayload, type RolePermissionsChangedPayload, discordPlugin as default, generateAllInviteUrls, generateInviteUrl, getPermissionValues, hasElevatedPermissions, isElevatedRole };
+export * from "./index";
+export { default } from "./index";