seedcord 0.4.3 → 0.5.0

package/dist/index.d.cts

@@ -1,13 +1,16 @@
 import { Logger, CoordinatedShutdown, CoordinatedStartup, StartupPhase } from '@seedcord/services';
 export * from '@seedcord/services';
-import { ClientOptions, Guild, User, SlashCommandBuilder, ContextMenuCommandBuilder, Collection, Client, ChatInputCommandInteraction, ButtonInteraction, ModalSubmitInteraction, AutocompleteInteraction, AnySelectMenuInteraction, ContextMenuCommandInteraction, ClientEvents, Events, AutocompleteFocusedOption, EmbedBuilder, ButtonBuilder, StringSelectMenuBuilder, StringSelectMenuOptionBuilder, UserSelectMenuBuilder, ChannelSelectMenuBuilder, MentionableSelectMenuBuilder, RoleSelectMenuBuilder, ModalBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, ContainerBuilder, TextDisplayBuilder, FileBuilder, MediaGalleryBuilder, SectionBuilder, SeparatorBuilder, ActionRowBuilder, TextInputBuilder, WebhookClient } from 'discord.js';
-import { Nullable, Tail, TypedConstructor, ConstructorFunction } from '@seedcord/types';
+import { ClientOptions, Guild, User, SlashCommandBuilder, ContextMenuCommandBuilder, Collection, Client, ChatInputCommandInteraction, ButtonInteraction, ModalSubmitInteraction, AutocompleteInteraction, AnySelectMenuInteraction, ContextMenuCommandInteraction, ClientEvents, Events, AutocompleteFocusedOption, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder, EmbedBuilder, ModalBuilder, LabelBuilder, TextInputBuilder, ButtonBuilder, StringSelectMenuBuilder, StringSelectMenuOptionBuilder, UserSelectMenuBuilder, ChannelSelectMenuBuilder, MentionableSelectMenuBuilder, RoleSelectMenuBuilder, ContainerBuilder, TextDisplayBuilder, FileBuilder, MediaGalleryBuilder, SectionBuilder, SeparatorBuilder, ActionRowBuilder, ColorResolvable, Interaction, Role, TextChannel, TextChannelResolvable, MessageActionRowComponentBuilder, Message, GuildMember, Snowflake, WebhookClient } from 'discord.js';
+import { Nullable, Tail, TypedConstructor, TypedExclude } from '@seedcord/types';
 export * from '@seedcord/types';
 import { UUID } from 'crypto';
+import { Constructor, RequireAtLeastOne } from 'type-fest';
+import { UUID as UUID$1 } from 'node:crypto';
 export * from '@seedcord/utils';
 
 /**
  * Djs Interactions handlers
+ *
  */
 interface InteractionsConfig {
     /**
@@ -15,6 +18,10 @@ interface InteractionsConfig {
      */
     path: string;
     ignoreCustomIds?: string[];
+    /**
+     * Optional path to interaction middleware directory
+     */
+    middlewares?: string;
 }
 /**
  * Djs Events handlers
@@ -24,6 +31,10 @@ interface EventsConfig {
      * Path to dir containing event handlers.
      */
     path: string;
+    /**
+     * Optional path to event middleware directory
+     */
+    middlewares?: string;
 }
 /**
  * Djs SlashCommands and ContextMenuCommands
@@ -63,6 +74,7 @@ interface BotConfig {
      *
      * @example
      * ```ts
+     * // This map's values...
      * const Emojis = {
      *   ThumbsUp: 'thumbsup',
      *   ThumbsDown: 'thumbsdown',
@@ -71,10 +83,9 @@ interface BotConfig {
      * };
      * ```
      *
-     * will turn into
-     *
      * @example
      * ```ts
+     * // ...turn into these Discord emojis
      * const Emojis = {
      *   ThumbsUp: '<:thumbsup:1872389747982323423>',
      *   ThumbsDown: '<:thumbsdown:1872389747982323424>',
@@ -107,6 +118,7 @@ interface DefaultEffects {
         error: Error;
         guild: Nullable<Guild>;
         user: Nullable<User>;
+        metadata?: unknown;
     };
 }
 /**
@@ -167,7 +179,10 @@ declare class EffectsRegistry extends Plugin {
     emit<KeyOfEffects extends EffectKeys>(event: KeyOfEffects, data: AllEffects[KeyOfEffects]): boolean;
 }
 
-/** Base interface defining core Seedcord functionality */
+/** Base interface defining core Seedcord functionality
+ *
+ * @internal
+ */
 interface BaseCore {
     readonly bot: Bot;
     readonly effects: EffectsRegistry;
@@ -219,12 +234,12 @@ declare abstract class Plugin implements Initializeable {
 }
 /**
  * Constructor type for plugins that can accept additional arguments after Core
- * @param TPlugin - The plugin type being constructed
+ * @typeParam TPlugin - The plugin type being constructed
  */
 type PluginCtor<TPlugin extends Plugin = Plugin> = new (core: Core, ...args: any[]) => TPlugin;
 /**
  * Extracts the argument types for a plugin constructor (excluding the Core parameter)
- * @param Ctor - The plugin constructor to extract arguments from
+ * @typeParam Ctor - The plugin constructor to extract arguments from
  */
 type PluginArgs<Ctor extends PluginCtor> = Tail<ConstructorParameters<Ctor>>;
 /**
@@ -300,10 +315,6 @@ declare class Bot extends Plugin {
     private readonly events;
     readonly commands: CommandRegistry;
     private readonly emojiInjector;
-    /**
-     * @param core - Seedcord core instance
-     * @internal
-     */
     constructor(core: Core);
     /**
      * Initializes Discord client and all controllers
@@ -385,6 +396,7 @@ interface Handler {
  * Should always accompany the `@Catchable` decorator. Will require the class to implement the `runChecks` method.
  *
  * @see {@link Checkable}
+ * @see {@link Catchable}
  */
 interface WithChecks {
     /**
@@ -396,8 +408,18 @@ interface WithChecks {
      */
     runChecks(): Promise<void>;
 }
+/**
+ * Interface for handlers that implement pre-execution checks
+ *
+ * @internal
+ */
 interface HandlerWithChecks extends WithChecks, Handler {
 }
+/**
+ * Base class for all handlers. Not meant to be used directly.
+ *
+ * @internal
+ */
 declare abstract class BaseHandler<ValidEvent extends ValidEventTypes> implements Handler {
     core: Core;
     protected checkable: boolean;
@@ -419,8 +441,8 @@ declare abstract class BaseHandler<ValidEvent extends ValidEventTypes> implement
     /**
      * Gets arguments parsed from interaction customId
      *
-     * Arguments are extracted from customId using ":" and "-" separators.
-     * For customId "accept:user123-guild456", returns ["user123", "guild456"]
+     * Arguments are extracted from customId using `:` and `-` separators.
+     * For customId `accept:user123-guild456`, returns `["user123", "guild456"]`
      */
     protected getArgs(): string[];
     /**
@@ -434,7 +456,7 @@ declare abstract class BaseHandler<ValidEvent extends ValidEventTypes> implement
  * Base class for Discord interaction handlers
  *
  * Extend this class to handle slash commands, buttons, modals, and select menus.
- * Use decorators like \@SlashRoute, \@ButtonRoute, etc. to define routing.
+ * Use decorators like `@SlashRoute`, `@ButtonRoute`, etc. to define routing.
  *
  * @typeParam Repliable - The interaction type this handler processes
  */
@@ -452,6 +474,14 @@ declare abstract class InteractionHandler<Repliable extends Repliables> extends
 declare abstract class InteractionMiddleware<Repliable extends Repliables> extends BaseHandler<Repliable> implements Handler {
     constructor(event: Repliable, core: Core, args?: string[]);
 }
+/**
+ * Base class for Discord event middleware
+ *
+ * Middleware runs before event handlers and can modify behavior or block execution.
+ */
+declare abstract class EventMiddleware<EventName extends keyof ClientEvents> extends BaseHandler<ClientEvents[EventName]> implements Handler {
+    constructor(event: ClientEvents[EventName], core: Core, args?: string[]);
+}
 /**
  * Handler for Discord autocomplete interactions
  *
@@ -459,7 +489,7 @@ declare abstract class InteractionMiddleware<Repliable extends Repliables> exten
  * The focused option is automatically available via the `focused` property.
  */
 declare abstract class AutocompleteHandler extends BaseHandler<AutocompleteInteraction> implements Handler {
-    /** The currently focused autocomplete option (Based on what you set in \@AutocompleteRoute) */
+    /** The currently focused autocomplete option (Based on what you set in `@AutocompleteRoute`) */
     protected readonly focused: AutocompleteFocusedOption;
     constructor(event: AutocompleteInteraction, core: Core, args?: string[]);
 }
@@ -467,7 +497,7 @@ declare abstract class AutocompleteHandler extends BaseHandler<AutocompleteInter
  * Base class for Discord client event handlers
  *
  * Extend this class to handle Discord events like messageCreate, guildMemberAdd, etc.
- * Use the \@EventRegisterable decorator to specify which event to listen for.
+ * Use the `EventRegisterable` decorator to specify which event to listen for.
  *
  * @typeParam Repliable - The Discord event type this handler processes
  */
@@ -477,12 +507,21 @@ declare abstract class EventHandler<Repliable extends keyof ClientEvents> extend
 /** Constructor type for interaction and autocomplete handlers */
 type HandlerConstructor = TypedConstructor<typeof InteractionHandler | typeof AutocompleteHandler>;
 /** Constructor type for interaction middleware */
-type MiddlewareConstructor = TypedConstructor<typeof InteractionMiddleware> & (new (event: Repliables, core: Core, args?: string[]) => InteractionMiddleware<Repliables>);
+type InteractionMiddlewareConstructor = TypedConstructor<typeof InteractionMiddleware> & (new (event: Repliables, core: Core, args?: string[]) => InteractionMiddleware<Repliables>);
+/** Constructor type for legacy interaction middleware */
+type MiddlewareConstructor = InteractionMiddlewareConstructor;
+/** Constructor type for event middleware */
+type EventMiddlewareConstructor = TypedConstructor<typeof EventMiddleware> & (new <EventName extends keyof ClientEvents>(event: ClientEvents[EventName], core: Core, args?: string[]) => EventMiddleware<EventName>);
 /** Constructor type for autocomplete handlers */
 type AutocompleteHandlerConstructor = TypedConstructor<typeof AutocompleteHandler> & (new (event: AutocompleteInteraction, core: Core, args?: string[]) => AutocompleteHandler);
 /** Constructor type for Discord client event handlers */
 type EventHandlerConstructor = TypedConstructor<typeof EventHandler>;
 
+/**
+ * Constructor type for handler classes.
+ *
+ * @internal
+ */
 type HandlerCtor = new (...args: any[]) => Handler;
 /**
  * Marks a handler class as requiring check execution.
@@ -490,12 +529,13 @@ type HandlerCtor = new (...args: any[]) => Handler;
  * Enables the runChecks() method to be called before execute()
  * for handlers that need pre-execution validation.
  *
- * @param ctor - The handler to mark as checkable (Do not pass this directly. Just call the decorator without a **()**)
+ * @typeParam TypeHandler - The type of the handler class being decorated
+ * @param ctor - The handler to mark as checkable (Do not pass this directly. Just call the decorator without a `()`)
  * @decorator
  * @example
  * ```typescript
  * \@Checkable
- * class AdminCommand extends InteractionHandler {
+ * class AdminCommand extends InteractionHandler implements WithChecks {
  *   async runChecks() {
  *     // Perform admin permission checks
  *   }
@@ -508,9 +548,9 @@ declare function Checkable<TypeHandler extends HandlerCtor>(ctor: TypeHandler):
  * Configuration options for the Catchable decorator.
  */
 interface CatchableOptions {
-    /** Whether to log errors to console (default: false) */
+    /** Whether to log errors to console (default: `false`) */
     log?: boolean;
-    /** Always use followUp instead of reply/editReply (default: false) */
+    /** Always use followUp instead of reply/editReply (default: `false`) */
     forceFollowup?: boolean;
 }
 /**
@@ -533,9 +573,20 @@ interface CatchableOptions {
  */
 declare function Catchable(options?: CatchableOptions): (_target: RepliableInteractionHandler, _propertyKey: string, descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<void>>) => void;
 
+/**
+ * Available Discord.js builder classes for use with BuilderComponent
+ *
+ * @internal
+ */
 declare const BuilderTypes: {
     command: typeof SlashCommandBuilder;
+    context_menu: typeof ContextMenuCommandBuilder;
+    subcommand: typeof SlashCommandSubcommandBuilder;
+    group: typeof SlashCommandSubcommandGroupBuilder;
     embed: typeof EmbedBuilder;
+    modal: typeof ModalBuilder;
+    label: typeof LabelBuilder;
+    text_input: typeof TextInputBuilder;
     button: typeof ButtonBuilder;
     menu_string: typeof StringSelectMenuBuilder;
     menu_option_string: typeof StringSelectMenuOptionBuilder;
@@ -543,10 +594,6 @@ declare const BuilderTypes: {
     menu_channel: typeof ChannelSelectMenuBuilder;
     menu_mentionable: typeof MentionableSelectMenuBuilder;
     menu_role: typeof RoleSelectMenuBuilder;
-    modal: typeof ModalBuilder;
-    context_menu: typeof ContextMenuCommandBuilder;
-    subcommand: typeof SlashCommandSubcommandBuilder;
-    group: typeof SlashCommandSubcommandGroupBuilder;
     container: typeof ContainerBuilder;
     text_display: typeof TextDisplayBuilder;
     file: typeof FileBuilder;
@@ -554,6 +601,11 @@ declare const BuilderTypes: {
     section: typeof SectionBuilder;
     separator: typeof SeparatorBuilder;
 };
+/**
+ * Available Discord.js action row classes for use with RowComponent
+ *
+ * @internal
+ */
 declare const RowTypes: {
     button: typeof ActionRowBuilder<ButtonBuilder>;
     menu_string: typeof ActionRowBuilder<StringSelectMenuBuilder>;
@@ -561,23 +613,31 @@ declare const RowTypes: {
     menu_channel: typeof ActionRowBuilder<ChannelSelectMenuBuilder>;
     menu_mentionable: typeof ActionRowBuilder<MentionableSelectMenuBuilder>;
     menu_role: typeof ActionRowBuilder<RoleSelectMenuBuilder>;
-    modal: typeof ActionRowBuilder<ModalActionRowComponentBuilder>;
-};
-declare const ModalTypes: {
-    text: typeof TextInputBuilder;
 };
+/**
+ * Available Discord.js builder types for use with BuilderComponent
+ */
 type BuilderType = keyof typeof BuilderTypes;
+/**
+ * @internal
+ */
 type InstantiatedBuilder<BuilderKey extends BuilderType> = InstanceType<(typeof BuilderTypes)[BuilderKey]>;
+/**
+ * Available Discord.js action row types for use with RowComponent
+ */
 type ActionRowComponentType = keyof typeof RowTypes;
+/**
+ * @internal
+ */
 type InstantiatedActionRow<RowKey extends ActionRowComponentType> = InstanceType<(typeof RowTypes)[RowKey]>;
-type ModalFieldTypes = keyof typeof ModalTypes;
-type InstantiatedModalField<ModalKey extends ModalFieldTypes> = InstanceType<(typeof ModalTypes)[ModalKey]>;
 /**
  * Base class for Discord component wrappers
  *
  * Provides common functionality for building Discord components with proper typing.
  *
  * @typeParam TComponent - The Discord.js component type being wrapped
+ *
+ * @internal
  */
 declare abstract class BaseComponent<TComponent> {
     private readonly _component;
@@ -603,7 +663,7 @@ declare abstract class BaseComponent<TComponent> {
     /**
      * Builds a customId string for interactive components
      *
-     * Creates customIds in the format "prefix:arg1-arg2-arg3" for buttons, modals, etc.
+     * Creates customIds in the format `prefix:arg1-arg2-arg3` for buttons, modals, etc.
      * Arguments are joined with hyphens and separated from prefix with a colon.
      *
      * @param prefix - The route prefix that handlers will match against
@@ -621,7 +681,13 @@ declare abstract class BaseComponent<TComponent> {
  * @typeParam BuilderKey - The type of Discord.js builder being wrapped
  */
 declare abstract class BuilderComponent<BuilderKey extends BuilderType> extends BaseComponent<InstantiatedBuilder<BuilderKey>> {
-    private readonly botColor;
+    /**
+     * Bot color for the component
+     * Uses the DEFAULT_BOT_COLOR environment variable or falls back to 'Default' set by Discord.js.
+     *
+     * Set DEFAULT_BOT_COLOR to a hex code in your `.env` file to customize.
+     */
+    readonly botColor: ColorResolvable;
     protected constructor(type: BuilderKey);
     get component(): InstantiatedBuilder<BuilderKey>;
 }
@@ -636,18 +702,6 @@ declare abstract class RowComponent<RowKey extends ActionRowComponentType> exten
     protected constructor(type: RowKey);
     get component(): InstantiatedActionRow<RowKey>;
 }
-/**
- * Base class for modal field components
- *
- * Wraps Discord.js modal field builders (TextInputBuilder, etc.) and
- * packages them in action rows for use in modals.
- *
- * @typeParam ModalKey - The type of modal field builder being wrapped
- */
-declare abstract class ModalComponent<ModalKey extends ModalFieldTypes> extends BaseComponent<InstantiatedModalField<ModalKey>> {
-    protected constructor(type: ModalKey);
-    get component(): InstantiatedActionRow<'modal'>;
-}
 /**
  * Pre-configured error embed with default styling
  *
@@ -680,24 +734,36 @@ declare abstract class CustomError extends Error {
     get emit(): boolean;
     /**
      * Sets whether this error should be emitted to logs
-     *
-     * @see {@link emit}
      */
     set emit(value: boolean);
 }
 /** Constructor type for custom error classes */
 type CustomErrorConstructor = new (message: string, ...args: any[]) => CustomError;
 
+/**
+ * Metadata key for command registration information.
+ *
+ * @internal
+ */
 declare const CommandMetadataKey: unique symbol;
+/**
+ * Constructor type for command classes.
+ *
+ * @internal
+ */
 type CommandCtor = new (...args: any[]) => BuilderComponent<'command' | 'context_menu'>;
 /**
  * Metadata for global command registration.
+ *
+ * @internal
  */
 interface GlobalMeta {
     scope: 'global';
 }
 /**
  * Metadata for guild-specific command registration.
+ *
+ * @internal
  */
 interface GuildMeta {
     scope: 'guild';
@@ -705,8 +771,16 @@ interface GuildMeta {
 }
 /**
  * Union type for command registration metadata.
+ *
+ * @internal
  */
 type CommandMeta = GlobalMeta | GuildMeta;
+/**
+ * Type representing command registration scope.
+ *
+ * @internal
+ */
+type CommandScope = CommandMeta['scope'];
 /**
  * Registers a command for global deployment.
  *
@@ -743,7 +817,7 @@ declare function RegisterCommand(scope: 'guild', guilds: string[]): (ctor: Comma
  * Automatically handles errors in event handlers and sends error responses
  * if the event contains a Discord message object.
  *
- * @param log - Whether to log errors to console (default: false)
+ * @param log - Whether to log errors to console (default: `false`)
  * @decorator
  * @example
  * ```typescript
@@ -759,12 +833,13 @@ declare function EventCatchable(log?: boolean): (_target: EventHandler<keyof Cli
 
 declare const EventMetadataKey: unique symbol;
 /**
- * Registers an event handler class with a specific Discord.js event.
+ * Registers an event handler class with a one or multiple Discord.js event(s).
  *
- * Associates the decorated class with a Discord client event for automatic
+ * Associates the decorated class with the mentioned Discord client event(s) for automatic
  * registration and execution when the event is emitted.
  *
- * @param eventName - The Discord.js event name to listen for
+ * @typeParam KeyofEvents - The key of the Discord.js ClientEvents to register for
+ * @param events - The Discord.js event name(s) to listen for
  * @decorator
  * @example
  * ```typescript
@@ -775,9 +850,24 @@ declare const EventMetadataKey: unique symbol;
  *   }
  * }
  * ```
+ *
+ * @example
+ * ```typescript
+ * \@RegisterEvent([Events.MessageCreate, Events.MessageUpdate])
+ * class MessageHandler extends EventHandler<Events.MessageCreate | Events.MessageUpdate> {
+ *   async execute() {
+ *     // Handle message creation or update
+ *   }
+ * }
+ * ```
  */
-declare function RegisterEvent<KeyofEvents extends keyof ClientEvents>(eventName: KeyofEvents): (constructor: ConstructorFunction) => void;
+declare function RegisterEvent<KeyofEvents extends keyof ClientEvents>(events: KeyofEvents | KeyofEvents[]): (constructor: Constructor<unknown>) => void;
 
+/**
+ * Enum defining interaction route types for decorators
+ *
+ * @internal
+ */
 declare enum InteractionRoutes {
     Slash = "interaction:slash",
     Button = "interaction:button",
@@ -791,6 +881,9 @@ declare enum InteractionRoutes {
     UserContextMenu = "interaction:userContextMenu",
     Autocomplete = "interaction:autocomplete"
 }
+/**
+ * Types of select menus supported for routing
+ */
 declare enum SelectMenuType {
     String = "string",
     User = "user",
@@ -798,6 +891,11 @@ declare enum SelectMenuType {
     Channel = "channel",
     Mentionable = "mentionable"
 }
+/**
+ * Metadata key used to mark classes as interaction handlers
+ *
+ * @internal
+ */
 declare const InteractionMetadataKey: unique symbol;
 /**
  * Routes slash commands to handler classes
@@ -813,29 +911,36 @@ declare const InteractionMetadataKey: unique symbol;
  * class PingCommand extends InteractionHandler {
  *   // handles /ping command
  * }
+ * ```
  *
+ * @example
+ * ```
  * \@SlashRoute(['ban', 'kick'])
  * class ModerationHandler extends InteractionHandler {
  *   // handles /ban and /kick commands
  * }
+ * ```
  *
+ * @example
+ * ```
  * \@SlashRoute('admin/user/promote')
  * class PromoteHandler extends InteractionHandler {
  *   // handles /admin user promote subcommand
  * }
  * ```
  */
-declare function SlashRoute(routeOrRoutes: string | string[]): (constructor: ConstructorFunction) => void;
+declare function SlashRoute(routeOrRoutes: string | string[]): (constructor: Constructor<unknown>) => void;
 /**
  * Routes button interactions to handler classes
  *
  * Matches the customId prefix before the first colon.
- * For customId "accept:user123", use \@ButtonRoute("accept").
+ *
+ * For customId `accept:user123`, use `@ButtonRoute("accept")`.
  *
  * @param routeOrRoutes - CustomId prefix(es) to handle
  * @decorator
  */
-declare function ButtonRoute(routeOrRoutes: string | string[]): (constructor: ConstructorFunction) => void;
+declare function ButtonRoute(routeOrRoutes: string | string[]): (constructor: Constructor<unknown>) => void;
 /**
  * Routes modal submissions to handler classes
  *
@@ -844,7 +949,7 @@ declare function ButtonRoute(routeOrRoutes: string | string[]): (constructor: Co
  * @param routeOrRoutes - CustomId prefix(es) to handle
  * @decorator
  */
-declare function ModalRoute(routeOrRoutes: string | string[]): (constructor: ConstructorFunction) => void;
+declare function ModalRoute(routeOrRoutes: string | string[]): (constructor: Constructor<unknown>) => void;
 /**
  * Routes context menu commands to handler classes
  *
@@ -852,7 +957,7 @@ declare function ModalRoute(routeOrRoutes: string | string[]): (constructor: Con
  * @param routeOrRoutes - Command name(s) to handle
  * @decorator
  */
-declare function ContextMenuRoute(type: 'message' | 'user', routeOrRoutes: string | string[]): (constructor: ConstructorFunction) => void;
+declare function ContextMenuRoute(type: 'message' | 'user', routeOrRoutes: string | string[]): (constructor: Constructor<unknown>) => void;
 /**
  * Routes autocomplete interactions to handler classes
  *
@@ -865,7 +970,7 @@ declare function ContextMenuRoute(type: 'message' | 'user', routeOrRoutes: strin
  * @example \@AutocompleteRoute(['user', 'profile'], ['name', 'bio']) // Multiple commands, multiple fields
  * @decorator
  */
-declare function AutocompleteRoute(commandRoutes: string | string[], focusedFields: string | string[]): (constructor: ConstructorFunction) => void;
+declare function AutocompleteRoute(commandRoutes: string | string[], focusedFields: string | string[]): (constructor: Constructor<unknown>) => void;
 /**
  * Routes select menu interactions to handler classes
  *
@@ -873,9 +978,393 @@ declare function AutocompleteRoute(commandRoutes: string | string[], focusedFiel
  *
  * @param type - Select menu type from {@link SelectMenuType}
  * @param routeOrRoutes - CustomId prefix(es) to handle
+ *
+ * @decorator
+ *
+ * @example
+ * ```typescript
+ * \@SelectMenuRoute(SelectMenuType.String, 'fruits')
+ * class RoleSelectHandler extends InteractionHandler {
+ *   // handles string select menus with customId starting with 'fruits'
+ * }
+ * ```
+ */
+declare function SelectMenuRoute(type: SelectMenuType, routeOrRoutes: string | string[]): (constructor: Constructor<unknown>) => void;
+
+/**
+ * Middleware types supported by Seedcord
+ */
+declare enum MiddlewareType {
+    Interaction = "middleware:interaction",
+    Event = "middleware:event"
+}
+/**
+ * Metadata key for middleware configuration
+ *
+ * @internal
+ */
+declare const MiddlewareMetadataKey: unique symbol;
+/**
+ * Additional middleware registration options
+ */
+interface MiddlewareOptions {
+    /**
+     * Restrict event middleware execution to specific Discord client events
+     */
+    readonly events?: readonly (keyof ClientEvents)[];
+}
+/**
+ * Metadata stored for middleware registration
+ */
+interface MiddlewareMetadata {
+    /**
+     * Priority number used to order middleware
+     */
+    priority: number;
+    /**
+     * Middleware kind from {@link MiddlewareType}
+     */
+    type: MiddlewareType;
+    /**
+     * Optional list of Discord client events to target
+     */
+    events?: readonly (keyof ClientEvents)[];
+}
+/**
+ * Decorator used to register middleware with priority ordering. The lower the priority number, the earlier it runs.
+ *
+ * Interaction middleware cannot specify event filters.
+ *
+ * @param type - Middleware kind from {@link MiddlewareType}
+ * @param priority - Ordering value where lower runs earlier. Default is 0
+ * @param options - Additional registration options
+ *
  * @decorator
+ *
+ * @example
+ * ```ts
+ * \@Middleware(MiddlewareType.Event, 10, { events: [Events.MessageCreate, Events.MessageUpdate] })
+ * class MyEventMiddleware extends EventMiddleware {}
+ * ```
+ * @throws A {@link TypeError} If priority is not a finite number
+ * @throws An {@link Error} If interaction middleware specifies event filters
+ */
+declare function Middleware(type: MiddlewareType, priority?: number, options?: MiddlewareOptions): ClassDecorator;
+
+/**
+ * Manages Discord event handler registration and execution.
+ *
+ * Scans event handler directories, registers handlers with Discord client events,
+ * and coordinates event execution through the handler system. Does not handle interactions.
+ *
+ * Multiple handlers can point to one event.
+ *
+ * @internal
  */
-declare function SelectMenuRoute(type: SelectMenuType, routeOrRoutes: string | string[]): (constructor: ConstructorFunction) => void;
+declare class EventController implements Initializeable {
+    protected core: Core;
+    private readonly logger;
+    private isInitialized;
+    private readonly eventMap;
+    private readonly middlewares;
+    constructor(core: Core);
+    init(): Promise<void>;
+    private loadHandlers;
+    private loadMiddlewares;
+    private registerMiddleware;
+    private runMiddlewares;
+    private isEventHandlerClass;
+    private isMiddlewareClass;
+    private registerHandler;
+    private attachToClient;
+    private processEvent;
+}
+
+/**
+ * Manages Discord interaction handling and routing.
+ *
+ * Scans handler directories, registers handlers with Discord client events,
+ * and coordinates event execution through the handler system. Only handles interactions.
+ *
+ * Enforces that there is only one handler per interaction.
+ *
+ * @internal
+ */
+declare class InteractionController implements Initializeable {
+    protected core: Core;
+    private readonly logger;
+    private isInitialized;
+    private readonly slashMap;
+    private readonly buttonMap;
+    private readonly modalMap;
+    private readonly stringSelectMap;
+    private readonly userSelectMap;
+    private readonly roleSelectMap;
+    private readonly channelSelectMap;
+    private readonly mentionableSelectMap;
+    private readonly messageContextMenuMap;
+    private readonly userContextMenuMap;
+    private readonly autocompleteMap;
+    private readonly keysToIgnore;
+    private readonly middlewares;
+    constructor(core: Core);
+    init(): Promise<void>;
+    private loadHandlers;
+    private loadMiddlewares;
+    private registerMiddleware;
+    private isHandlerClass;
+    private isMiddlewareClass;
+    private registerHandler;
+    private attachToClient;
+    private parseCustomId;
+    private handleCustomIdInteraction;
+    processInteraction<TInteraction extends Interaction>(interaction: TInteraction, extractKey: (i: TInteraction) => string, getHandler: (key: string) => HandlerConstructor | undefined, args?: string[]): Promise<void>;
+    private handleInteraction;
+    private handleSlashCommand;
+    private handleButton;
+    private handleModal;
+    private handleStringSelectMenu;
+    private handleUserSelectMenu;
+    private handleRoleSelectMenu;
+    private handleChannelSelectMenu;
+    private handleMentionableSelectMenu;
+    private handleMessageContextMenu;
+    private handleUserContextMenu;
+    private handleAutocomplete;
+}
+
+/**
+ * Error thrown when a requested channel cannot be found.
+ */
+declare class ChannelNotFoundError extends CustomError {
+    readonly channelId: string;
+    /**
+     * Creates a new ChannelNotFoundError.
+     *
+     * @param message - The error message
+     * @param channelId - The ID of the channel that could not be found
+     */
+    constructor(message: string, channelId: string);
+}
+/**
+ * Error thrown when the bot cannot send embeds in a channel.
+ */
+declare class CannotSendEmbedsError extends CustomError {
+    readonly channelId: string;
+    /**
+     * Creates a new CannotSendEmbedsError.
+     *
+     * @param message - The error message
+     * @param channelId - The ID of the channel where embeds cannot be sent
+     */
+    constructor(message: string, channelId: string);
+}
+/**
+ * Error thrown when a channel could not be found or accessed.
+ */
+declare class CouldNotFindChannel extends CustomError {
+    readonly channelId: string;
+    /**
+     * Creates a new CouldNotFindChannel error.
+     *
+     * @param message - The error message
+     * @param channelId - The ID of the channel that could not be found
+     */
+    constructor(message: string, channelId: string);
+}
+/**
+ * Error thrown when a channel is not a text channel.
+ */
+declare class ChannelNotTextChannel extends CustomError {
+    readonly channelId: string;
+    /**
+     * Creates a new ChannelNotTextChannel error.
+     *
+     * @param message - The error message
+     * @param channelId - The ID of the channel that is not a text channel
+     */
+    constructor(message: string, channelId: string);
+}
+
+/**
+ * Generic database operation error with UUID tracking.
+ *
+ * Thrown for various database operation failures and includes
+ * a UUID for error tracking and debugging purposes.
+ */
+declare class DatabaseError extends CustomError {
+    uuid: UUID;
+    /**
+     * Creates a new DatabaseError.
+     *
+     * @param message - The error message describing what went wrong
+     * @param uuid - A unique identifier for this specific error instance
+     */
+    constructor(message: string, uuid: UUID);
+}
+
+/**
+ * Error thrown when the bot lacks necessary permissions to perform an action.
+ */
+declare class MissingPermissions extends CustomError {
+    missingPerms: string[];
+    roleOrChannel: Role | TextChannel;
+    /**
+     * Creates a new BotMissingPermissionsError.
+     *
+     * @param message - The error message
+     * @param missingPerms - Array of missing permission names
+     * @param roleOrChannel - The role or channel where permissions are missing
+     */
+    constructor(message: string, missingPerms: string[], roleOrChannel: Role | TextChannel);
+}
+/**
+ * Error thrown when attempting to modify a role higher than the bot's highest role.
+ */
+declare class RoleHigherThanMe extends CustomError {
+    role: Role;
+    botRole: Role;
+    /**
+     * Creates a new RoleHigherThanMe error.
+     *
+     * @param message - The error message
+     */
+    constructor(message: string, role: Role, botRole: Role);
+}
+/**
+ * Error thrown when attempting to assign a managed/bot role.
+ */
+declare class CannotAssignBotRole extends CustomError {
+    /**
+     * Creates a new CannotAssignBotRole error.
+     *
+     * @param message - The error message
+     */
+    constructor(message?: string);
+}
+/**
+ * Error thrown when a requested role does not exist.
+ */
+declare class RoleDoesNotExist extends CustomError {
+    roleId: string;
+    /**
+     * Creates a new RoleDoesNotExist error.
+     *
+     * @param message - The error message
+     * @param roleId - The ID of the role that doesn't exist
+     */
+    constructor(message: string, roleId: string);
+}
+/**
+ * Error thrown when a role has dangerous permissions that shouldn't be assigned.
+ */
+declare class HasDangerousPermissions extends CustomError {
+    role: Role;
+    dangerousPerms: string[];
+    /**
+     * Creates a new HasDangerousPermissions error.
+     *
+     * @param message - The error message
+     * @param role - The role with dangerous permissions
+     * @param dangerousPerms - Array of dangerous permission names
+     */
+    constructor(message: string, role: Role, dangerousPerms: string[]);
+}
+
+/**
+ * Error thrown when attempting to perform actions on a user not in the guild.
+ */
+declare class UserNotInGuild extends CustomError {
+    /**
+     * Creates a new UserNotInGuild error.
+     *
+     * @param message - The error message
+     */
+    constructor(message?: string);
+}
+/**
+ * Error thrown when a requested user cannot be found.
+ */
+declare class UserNotFound extends CustomError {
+    readonly userArg: string;
+    /**
+     * Creates a new UserNotFound error.
+     *
+     * @param userArg - The user argument that could not be resolved
+     */
+    constructor(userArg: string);
+}
+
+declare class EmojiInjector {
+    private readonly core;
+    private readonly logger;
+    constructor(core: Core);
+    init(): Promise<void>;
+}
+
+/**
+ * Fetches and validates a text channel.
+ *
+ * @param client - The Discord client instance
+ * @param channelId - Channel ID or TextChannel instance
+ * @returns Promise resolving to the text channel
+ * @throws A {@link CouldNotFindChannel} When the channel doesn't exist or isn't text-based
+ */
+declare function fetchText(client: Client, channelId: TextChannelResolvable): Promise<TextChannel>;
+
+/** Discord message content with embeds and components */
+interface MessageContent {
+    embeds: EmbedBuilder[];
+    components: [ActionRowBuilder<MessageActionRowComponentBuilder>];
+}
+/** Discord message that requires at least one of content, embeds, or components */
+type AtleastOneMessageComponent = RequireAtLeastOne<{
+    content: string;
+} & MessageContent>;
+
+/**
+ * Sends a message to a text channel by ID.
+ *
+ * @param client - The Discord client instance
+ * @param channelId - Channel ID or TextChannel instance
+ * @param message - Message content to send
+ * @returns Promise resolving to the sent message
+ * @throws A {@link CouldNotFindChannel} When the channel doesn't exist or isn't text-based
+ */
+declare function sendInText(client: Client, channelId: TextChannelResolvable, message: AtleastOneMessageComponent): Promise<Message>;
+
+/**
+ * Structure representing the extracted error response.
+ */
+interface ExtractedErrorResponse {
+    /** The unique identifier for the error instance */
+    uuid: UUID$1;
+    /** The formatted error response to be sent to the user */
+    response: EmbedBuilder;
+}
+/**
+ * Processes an error and extracts the standardized response, if available (else returns a {@link GenericError}).
+ *
+ * Handles different error types (CustomError, DatabaseError) with appropriate
+ * logging, side effects, and user-facing error messages.
+ *
+ * @param error - The error to process
+ * @param core - The core framework instance
+ * @param guild - The guild where the error occurred (if any)
+ * @param user - The user who triggered the error (if any)
+ * @returns Object containing UUID and formatted error response embed
+ */
+declare function extractErrorResponse(error: Error, core: Core, guild: Nullable<Guild>, user: Nullable<User>, metadata?: unknown): ExtractedErrorResponse;
+/**
+ * Generic error shown to users when an unknown error occurs
+ *
+ * Set an environment variable called `DEVELOPER_DISCORD_USERNAME` in your `.env` file to customize the contact name.
+ */
+declare class GenericError extends CustomError {
+    private readonly uuid;
+    private readonly developerUsername;
+    constructor(uuid: UUID$1);
+}
 
 /**
  * Throws a custom error with a formatted message and optional UUID.
@@ -883,7 +1372,7 @@ declare function SelectMenuRoute(type: SelectMenuType, routeOrRoutes: string | s
  * Wraps an unknown error in a {@link CustomError} subclass. If the error class
  * is {@link DatabaseError}, a UUID is generated and passed to the constructor.
  *
- * @typeParam T - A constructor for a {@link CustomError} subclass
+ * @typeParam Ctor - A constructor for a {@link CustomError} subclass
  * @param error - The original error or value
  * @param message - Custom message to include
  * @param CustomError - Error class to instantiate and throw
@@ -900,6 +1389,171 @@ declare function SelectMenuRoute(type: SelectMenuType, routeOrRoutes: string | s
  */
 declare function throwCustomError<Ctor extends CustomErrorConstructor>(error: unknown, message: string, CustomError: Ctor): never;
 
+/**
+ * Sends a direct message to a user.
+ *
+ * @param user - The user to send the DM to
+ * @param content - Message content with embeds, components, etc.
+ * @returns Promise resolving to the sent message, or null if DM failed
+ */
+declare function attemptSendDM(user: User, content: AtleastOneMessageComponent): Promise<Nullable<Message>>;
+
+/**
+ * Route string computed from provided parts.
+ *
+ * @typeParam Cmmd - Main command name
+ * @typeParam Subc - Subcommand name
+ * @typeParam Grp - Group name (will be ignored if subcommand is not provided with it)
+ */
+type CommandRouteString<Cmmd extends string, Subc extends string | undefined, Grp extends string | undefined> = Subc extends string ? (Grp extends string ? `${Cmmd}/${Grp}/${Subc}` : `${Cmmd}/${Subc}`) : Cmmd;
+/**
+ * From provided positional arguments. Either provide the route to either {@link SlashRoute} or {@link AutocompleteRoute} manually, or use this utility to build it.
+ *
+ * @param command - Main command name
+ * @param subcommand - Optional subcommand name
+ * @param group - Optional group name (will be ignored if subcommand is not provided with it)
+ */
+declare function buildSlashRoute<Cmmd extends string, Subc extends string | undefined = undefined, Grp extends string | undefined = undefined>(command: Cmmd, subcommand?: Subc, group?: Grp): CommandRouteString<Cmmd, Subc, Grp>;
+/**
+ * From a Discord interaction. The {@link InteractionController} uses this internally to build the route string to then route the correct handler.
+ *
+ * @internal
+ */
+declare function buildSlashRoute(interaction: ChatInputCommandInteraction | AutocompleteInteraction): string;
+
+/**
+ * Map of permission bits to their prettified human-readable names.
+ */
+declare const PermissionNames: Map<bigint, string>;
+/**
+ * Defines the scope types for bot permission validation.
+ */
+type BotPermissionScope = 'manage' | 'others' | 'all' | bigint[] | 'embed';
+/**
+ * Defines the valid group types for permission checking, excluding 'all' and bigint[].
+ */
+type BotPermissionScopeGroups = TypedExclude<BotPermissionScope, 'all' | bigint[]>;
+/**
+ * Predefined permission groups for different scopes.
+ */
+declare const PERM_GROUPS: Record<BotPermissionScopeGroups, Map<bigint, string>>;
+/**
+ * Checks permissions for a {@link Role}.
+ *
+ * @param client - The Discord client instance
+ * @param roleOrChannel - Role to check permissions for
+ * @param scope - Permission scope to validate
+ * @param inverse - Whether to check for absence of permissions (role only). Defaults to false.
+ * @throws A {@link MissingPermissions} When required permissions are missing
+ * @throws A {@link HasDangerousPermissions} When role has dangerous permissions (if inverse is true)
+ */
+declare function checkPermissions(client: Client, roleOrChannel: Role, scope: BotPermissionScope, inverse?: boolean): void;
+/**
+ * Checks permissions for a {@link TextChannel}.
+ *
+ * @param client - The Discord client instance
+ * @param roleOrChannel - TextChannel to check permissions for
+ * @param scope - Permission scope to validate
+ * @throws A {@link MissingPermissions} When required permissions are missing
+ */
+declare function checkPermissions(client: Client, roleOrChannel: TextChannel, scope?: BotPermissionScope): void;
+
+/**
+ * Checks if the bot has required permissions in a guild or channel.
+ *
+ * @param client - The Discord client instance
+ * @param guildOrChannel - Guild or text channel to check permissions in
+ * @param scope - Permission scope to validate
+ * @param inverse - Whether to check for absence of permissions
+ * @throws A {@link MissingPermissions} When bot lacks required permissions
+ */
+declare function checkBotPermissions(client: Client, guildOrChannel: Guild | TextChannel, scope?: BotPermissionScope, inverse?: boolean): void;
+
+/**
+ * Fetches a role by ID from a client or guild.
+ *
+ * @param clientOrGuild - Discord client or guild instance
+ * @param roleId - The role ID to fetch
+ * @returns Promise resolving to the role
+ * @throws A {@link RoleDoesNotExist} When the role doesn't exist
+ */
+declare function fetchRole(clientOrGuild: Client | Guild, roleId: string): Promise<Role>;
+
+/**
+ * Gets the bot's highest role in a guild.
+ *
+ * @param client - The Discord client instance
+ * @param guild - The guild to get the bot's role from
+ * @returns The bot's highest role in the guild
+ * @throws An {@link Error} When the bot is not in the guild
+ */
+declare function getBotRole(client: Client, guild: Guild): Role;
+
+/**
+ * Validates if the bot has permission to assign a target role.
+ *
+ * @param targetRole - The role to check assignment permissions for
+ * @throws A {@link RoleHigherThanMe} When the target role is higher than bot's role
+ * @throws A {@link CannotAssignBotRole} When trying to assign a managed/bot role
+ * @throws A {@link MissingPermissions} When bot lacks Manage Roles permission
+ */
+declare function hasPermsToAssign(targetRole: Role): void;
+
+/**
+ * Fetches a guild member by user ID with error handling.
+ *
+ * @param guild - The guild to fetch the member from
+ * @param userId - The Discord user ID
+ * @returns Promise resolving to the guild member
+ * @throws A {@link UserNotInGuild} When the user is not found in the guild
+ */
+declare function fetchGuildMember(guild: Guild, userId: string): Promise<GuildMember>;
+
+/**
+ * Fetches multiple guild members by user IDs.
+ *
+ * @param guild - The guild to fetch members from
+ * @param userIds - Array of Discord user IDs
+ * @returns Promise resolving to array of successfully fetched members
+ */
+declare function fetchManyGuildMembers(guild: Guild, userIds: string[]): Promise<GuildMember[]>;
+
+/**
+ * Fetches multiple Discord users by IDs.
+ *
+ * @param client - The Discord client instance
+ * @param userIds - Array of Discord user IDs
+ * @returns Promise resolving to array of successfully fetched users
+ */
+declare function fetchManyUsers(client: Client, userIds: string[]): Promise<User[]>;
+
+/**
+ * Fetches a Discord user by ID with error handling.
+ *
+ * @param client - The Discord client instance
+ * @param userId - The Discord user ID
+ * @returns Promise resolving to the user
+ * @throws A {@link UserNotFound} When the user doesn't exist
+ */
+declare function fetchUser(client: Client, userId: string): Promise<User>;
+
+/**
+ * Updates a guild member's roles by adding and removing specified roles.
+ *
+ * @param rolesToAdd - Array of role IDs to add to the member
+ * @param rolesToRemove - Array of role IDs to remove from the member
+ * @param member - The guild member to update
+ * @returns Promise that resolves when roles are updated
+ */
+declare function updateMemberRoles(rolesToAdd: Snowflake[], rolesToRemove: Snowflake[], member: GuildMember): Promise<void>;
+
+/**
+ * Default handler for unhandled interaction.
+ */
+declare class UnhandledEvent extends InteractionHandler<Repliables> {
+    execute(): Promise<void>;
+}
+
 /**
  * Type-safe event emitter for application effects.
  *
@@ -907,6 +1561,8 @@ declare function throwCustomError<Ctor extends CustomErrorConstructor>(error: un
  * for Seedcord's effect system.
  *
  * @typeParam AllEffects - Side effect definitions mapping event names to data types
+ *
+ * @internal
  */
 declare class EffectsEmitter {
     private readonly emitter;
@@ -939,6 +1595,11 @@ declare class EffectsEmitter {
     emit<KeyOfEffects extends EffectKeys>(event: KeyOfEffects, data: AllEffects[KeyOfEffects]): boolean;
 }
 
+/**
+ * Metadata key used to store effect handler information
+ *
+ * @internal
+ */
 declare const EffectMetadataKey: unique symbol;
 /**
  * Registers a side effect handler class with a specific side effect event.
@@ -946,6 +1607,7 @@ declare const EffectMetadataKey: unique symbol;
  * Associates the decorated class with a side effect event type for automatic
  * registration and execution when the side effect is emitted.
  *
+ * @typeParam TEffect - The side effect event name to register for
  * @param effect - The side effect event name to register for
  * @decorator
  * @example
@@ -958,7 +1620,7 @@ declare const EffectMetadataKey: unique symbol;
  * }
  * ```
  */
-declare function RegisterEffect<TEffect extends EffectKeys>(effect: TEffect): (constructor: ConstructorFunction) => void;
+declare function RegisterEffect<TEffect extends EffectKeys>(effect: TEffect): (constructor: Constructor<unknown>) => void;
 
 /**
  * Abstract base class for handling application side effects.
@@ -1000,20 +1662,24 @@ declare abstract class WebhookLog<KeyOfEffects extends EffectKeys> extends Effec
 }
 
 /**
- * Generic database operation error with UUID tracking.
+ * Default effect to log unhandled exceptions via webhook. It provides basic information about the error:
+ * - Error stack trace
+ * - Guild ID and name (if applicable)
+ * - User ID and username (if applicable)
+ * - A unique UUID for tracking
+ * - Timestamps comparing interaction time and error log time (if applicable)
+ * - Metadata associated with the error (if provided)
  *
- * Thrown for various database operation failures and includes
- * a UUID for error tracking and debugging purposes.
+ * Developers need to set the UNKNOWN_EXCEPTION_WEBHOOK_URL environment variable in their .env file otherwise this effect will throw an error during initialization.
+ *
+ * @throws Error if UNKNOWN_EXCEPTION_WEBHOOK_URL is not set or is invalid
  */
-declare class DatabaseError extends CustomError {
-    uuid: UUID;
-    /**
-     * Creates a new DatabaseError.
-     *
-     * @param message - The error message describing what went wrong
-     * @param uuid - A unique identifier for this specific error instance
-     */
-    constructor(message: string, uuid: UUID);
+declare class UnknownException extends WebhookLog<'unknownException'> {
+    private static readonly logger;
+    static readonly unknownExceptionWebhookUrl: string;
+    webhook: WebhookClient;
+    execute(): Promise<void>;
+    private prepareMetadataFile;
 }
 
-export { type AllEffects, AutocompleteHandler, type AutocompleteHandlerConstructor, AutocompleteRoute, BaseErrorEmbed, Bot, BuilderComponent, ButtonRoute, Catchable, Checkable, type CommandMeta, CommandMetadataKey, type Config, ContextMenuRoute, type Core, CustomError, type CustomErrorConstructor, DatabaseError, type DefaultEffects, type EffectKeys, EffectMetadataKey, type EffectParams, type Effects, EffectsEmitter, EffectsHandler, EffectsRegistry, EventCatchable, EventHandler, type EventHandlerConstructor, EventMetadataKey, type Handler, type HandlerConstructor, type Initializeable, InteractionHandler, InteractionMetadataKey, InteractionMiddleware, InteractionRoutes, type MiddlewareConstructor, ModalComponent, ModalRoute, Pluggable, Plugin, type PluginArgs, type PluginCtor, RegisterCommand, RegisterEffect, RegisterEvent, type RepliableInteractionHandler, type Repliables, RowComponent, Seedcord, SelectMenuRoute, SelectMenuType, SlashRoute, type ValidEventTypes, type ValidInteractionTypes, type ValidNonInteractionTypes, WebhookLog, type WithChecks, throwCustomError };
+export { type ActionRowComponentType, type AllEffects, type AtleastOneMessageComponent, AutocompleteHandler, type AutocompleteHandlerConstructor, AutocompleteRoute, BaseComponent, type BaseCore, BaseErrorEmbed, BaseHandler, Bot, type BotConfig, type BotPermissionScope, type BotPermissionScopeGroups, BuilderComponent, type BuilderType, BuilderTypes, ButtonRoute, CannotAssignBotRole, CannotSendEmbedsError, Catchable, type CatchableOptions, ChannelNotFoundError, ChannelNotTextChannel, Checkable, type CommandCtor, type CommandMeta, CommandMetadataKey, CommandRegistry, type CommandRouteString, type CommandScope, type CommandsConfig, type Config, ContextMenuRoute, type Core, CouldNotFindChannel, CustomError, type CustomErrorConstructor, DatabaseError, type DefaultEffects, type EffectKeys, EffectMetadataKey, type EffectParams, type Effects, type EffectsConfig, EffectsEmitter, EffectsHandler, EffectsRegistry, EmojiInjector, EventCatchable, EventController, EventHandler, type EventHandlerConstructor, EventMetadataKey, EventMiddleware, type EventMiddlewareConstructor, type EventsConfig, type ExtractedErrorResponse, GenericError, type GlobalMeta, type GuildMeta, type Handler, type HandlerConstructor, type HandlerCtor, type HandlerWithChecks, HasDangerousPermissions, type Initializeable, type InstantiatedActionRow, type InstantiatedBuilder, InteractionController, InteractionHandler, InteractionMetadataKey, InteractionMiddleware, type InteractionMiddlewareConstructor, InteractionRoutes, type InteractionsConfig, type MessageContent, Middleware, type MiddlewareConstructor, type MiddlewareMetadata, MiddlewareMetadataKey, type MiddlewareOptions, MiddlewareType, MissingPermissions, ModalRoute, PERM_GROUPS, PermissionNames, Pluggable, Plugin, type PluginArgs, type PluginCtor, RegisterCommand, RegisterEffect, RegisterEvent, type RepliableInteractionHandler, type Repliables, RoleDoesNotExist, RoleHigherThanMe, RowComponent, RowTypes, Seedcord, SelectMenuRoute, SelectMenuType, SlashRoute, UnhandledEvent, UnknownException, UserNotFound, UserNotInGuild, type ValidEventTypes, type ValidInteractionTypes, type ValidNonInteractionTypes, WebhookLog, type WithChecks, attemptSendDM, buildSlashRoute, checkBotPermissions, checkPermissions, extractErrorResponse, fetchGuildMember, fetchManyGuildMembers, fetchManyUsers, fetchRole, fetchText, fetchUser, getBotRole, hasPermsToAssign, sendInText, throwCustomError, updateMemberRoles };