seedcord 0.3.0 → 0.4.1

package/package.json

@@ -1,23 +1,20 @@
 {
   "name": "seedcord",
   "type": "module",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "A Discord bot framework built on top of Discord.js",
   "repository": {
     "type": "git",
     "url": "https://github.com/materwelondhruv/seedcord.git",
     "directory": "packages/seedcord"
   },
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
     }
   },
   "files": [
@@ -27,24 +24,24 @@
     "LICENSE"
   ],
   "peerDependencies": {
-    "typescript": "5.9.2"
+    "typescript": "5.9.3"
   },
   "dependencies": {
     "chalk": "5.6.2",
     "discord.js": "14.22.1",
     "envapt": "3.0.2",
     "reflect-metadata": "0.2.2",
-    "@seedcord/types": "^0.1.4",
-    "@seedcord/utils": "0.1.1",
-    "@seedcord/services": "0.1.1"
+    "@seedcord/types": "^0.2.1",
+    "@seedcord/utils": "0.2.1",
+    "@seedcord/services": "0.2.1"
   },
   "devDependencies": {
-    "@seedcord/eslint-config": "^1.1.2",
-    "@seedcord/tsconfig": "^1.0.3",
-    "@seedcord/tsup-config": "^1.0.3"
+    "@seedcord/tsconfig": "^1.0.4",
+    "@seedcord/eslint-config": "^1.2.1",
+    "@seedcord/tsup-config": "^1.0.4"
   },
   "scripts": {
-    "build": "tsup && cp dist/index.d.cts dist/index.d.mts",
+    "build": "tsup",
     "clean": "rm -rf dist",
     "lint": "eslint 'src/**/*.{ts,tsx}' --cache",
     "lint:fix": "eslint 'src/**/*.{ts,tsx}' --fix --cache",

package/dist/index.d.mts

@@ -1,1019 +0,0 @@
-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';
-export * from '@seedcord/types';
-import { UUID } from 'crypto';
-export * from '@seedcord/utils';
-
-/**
- * Djs Interactions handlers
- */
-interface InteractionsConfig {
-    /**
-     * Path to dir containing interaction handlers.
-     */
-    path: string;
-    ignoreCustomIds?: string[];
-}
-/**
- * Djs Events handlers
- */
-interface EventsConfig {
-    /**
-     * Path to dir containing event handlers.
-     */
-    path: string;
-}
-/**
- * Djs SlashCommands and ContextMenuCommands
- */
-interface CommandsConfig {
-    /**
-     * Path to dir containing commands and context menus to register.
-     */
-    path: string;
-}
-/**
- * Application side effects configuration
- */
-interface EffectsConfig {
-    /**
-     * Path to dir of user defined side effects.
-     */
-    path: string;
-}
-/**
- * Discord bot configuration
- */
-interface BotConfig {
-    interactions: InteractionsConfig;
-    events: EventsConfig;
-    commands: CommandsConfig;
-    /**
-     * Discord.js ClientOptions passed directly to the Client constructor
-     */
-    clientOptions: ClientOptions;
-    /**
-     * Optional emoji mappings. Pass an object with emojis mappings (e.g. below). These emojis will be loaded from the Application Emojis that you've uploaded via the Dev-Dashboard
-     *
-     * Key: The name of the object key you want to use in your codebase
-     *
-     * Value: The emoji identifier used in Discord
-     *
-     * @example
-     * ```ts
-     * const Emojis = {
-     *   ThumbsUp: 'thumbsup',
-     *   ThumbsDown: 'thumbsdown',
-     *   Lol: 'lol_1',
-     *   Kek: 'keklmao',
-     * };
-     * ```
-     *
-     * will turn into
-     *
-     * @example
-     * ```ts
-     * const Emojis = {
-     *   ThumbsUp: '<:thumbsup:1872389747982323423>',
-     *   ThumbsDown: '<:thumbsdown:1872389747982323424>',
-     *   Lol: '<:lol_1:1872389747982323425>',
-     *   Kek: '<a:keklmao:1872389747982323426>',
-     * };
-     * ```
-     */
-    emojis?: Record<string, string>;
-    /**
-     * Whether to show the error stack trace in the terminal in errors caught by the `@Catchable` decorator
-     *
-     * `false` by default
-     */
-    errorStack?: boolean;
-}
-/** Main configuration object for Seedcord bot */
-interface Config {
-    bot: BotConfig;
-    effects: EffectsConfig;
-}
-
-/**
- * Default side effects that are always available in the framework.
- */
-interface DefaultEffects {
-    /** Triggered when an unhandled exception occurs */
-    unknownException: {
-        uuid: UUID;
-        error: Error;
-        guild: Nullable<Guild>;
-        user: Nullable<User>;
-    };
-}
-/**
- * Custom side effects defined by the application.
- *
- * This interface can be augmented via declaration merging to add
- * type-safe custom effect definitions for emitting custom side effects anywhere in the application.
- *
- * @example
- * ```typescript
- * declare module 'seedcord' {
- *   interface Effects {
- *     'userJoin': { user: User; guild: Guild };
- *     'levelUp': { user: User; level: number; guild: Guild };
- *   }
- * }
- * ```
- */
-interface Effects {
-}
-/**
- * Combined effects interface containing both default and custom side effects.
- */
-interface AllEffects extends DefaultEffects, Effects {
-}
-/**
- * Helper type to extract all available effect event names.
- */
-type EffectKeys = keyof AllEffects;
-/**
- * Helper type to get parameters for a specific effect event.
- *
- * @typeParam KeyOfEffects - The effect event name
- */
-type EffectParams<KeyOfEffects extends EffectKeys> = AllEffects[KeyOfEffects];
-
-/**
- * Manages application effects and event handling
- *
- * Provides a centralized system for registering and executing custom effects
- * throughout the application lifecycle. Effects are loaded from configured directories
- * and can be triggered programmatically or by framework events.
- *
- * @internal Accessed via core.effects, not directly instantiated
- */
-declare class EffectsRegistry extends Plugin {
-    protected core: Core;
-    readonly logger: Logger;
-    private isInitialized;
-    private readonly effectsMap;
-    private readonly emitter;
-    constructor(core: Core);
-    init(): Promise<void>;
-    private loadEffects;
-    private registerEffect;
-    private isEffectHandler;
-    private attachEffects;
-    emit<KeyOfEffects extends EffectKeys>(event: KeyOfEffects, data: AllEffects[KeyOfEffects]): boolean;
-}
-
-/** Base interface defining core Seedcord functionality */
-interface BaseCore {
-    readonly bot: Bot;
-    readonly effects: EffectsRegistry;
-    readonly shutdown: CoordinatedShutdown;
-    readonly startup: CoordinatedStartup;
-    readonly config: Config;
-    start(): Promise<this>;
-}
-/**
- * Main interface for Seedcord core functionality
- *
- * This interface can be augmented via declaration merging to add
- * type-safe plugin definitions when using `this.core#` in handlers.
- *
- * Only add classes that extend {@link Plugin} to this
- *
- * @example
- * ```typescript
- * declare module 'seedcord' {
- *   interface Core {
- *     db: Mongo;
- *   }
- * }
- * ```
- * */
-interface Core extends BaseCore {
-}
-
-/** Interface for objects that can be initialized asynchronously */
-interface Initializeable {
-    init(): Promise<void>;
-}
-/**
- * Base class for Seedcord plugins
- *
- * Extend this class to create plugins that integrate with the Seedcord lifecycle.
- * Plugins have access to the core instance and must implement initialization logic.
- */
-declare abstract class Plugin implements Initializeable {
-    protected pluggable: Core;
-    /** Logger instance for this plugin - must be implemented by subclasses */
-    abstract logger: Logger;
-    constructor(pluggable: Core);
-    /**
-     * Initialize the plugin - implement setup logic here
-     * @virtual Override this method in your plugin classes
-     */
-    abstract init(): Promise<void>;
-}
-/**
- * Constructor type for plugins that can accept additional arguments after Core
- * @param 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
- */
-type PluginArgs<Ctor extends PluginCtor> = Tail<ConstructorParameters<Ctor>>;
-/**
- * Base class for objects that can have plugins attached
- *
- * Provides plugin attachment capabilities and lifecycle management.
- * Plugins are attached during configuration and initialized during startup.
- */
-declare class Pluggable {
-    protected isInitialized: boolean;
-    protected readonly shutdown: CoordinatedShutdown;
-    protected readonly startup: CoordinatedStartup;
-    private static readonly PLUGIN_INIT_TIMEOUT_MS;
-    constructor(shutdown: CoordinatedShutdown, startup: CoordinatedStartup);
-    protected init(): Promise<this>;
-    /**
-     * Attaches a plugin to this instance
-     *
-     * Plugins provide external functionality and are initialized during the specified startup phase.
-     * The plugin instance becomes available as a property in `core` wherever it's available.
-     *
-     * Make sure to augment the {@link Core} interface with the plugin type to ensure TypeScript recognizes it and provides intellisense.
-     *
-     * @typeParam Key - The property name for accessing the plugin
-     * @typeParam Ctor - The plugin constructor type
-     * @param key - Property name to access the plugin instance
-     * @param Plugin - Plugin constructor class
-     * @param startupPhase - When during startup to initialize this plugin ({@link StartupPhase})
-     * @param args - Additional arguments to pass to the plugin constructor
-     * @returns This instance with the plugin attached as a typed property
-     * @throws An {@link Error} When called after initialization or if key already exists
-     * @example
-     * ```typescript
-     * seedcord.attach('db', Mongo, StartupPhase.Configuration, { uri: 'mongodb://...', name: 'seedcord', dir: ... })
-     * ```
-     */
-    attach<Key extends string, Ctor extends PluginCtor>(this: this, key: Key, Plugin: Ctor, startupPhase: StartupPhase, ...args: PluginArgs<Ctor>): this & Record<Key, InstanceType<Ctor>>;
-}
-
-/**
- * Manages Discord application command registration and deployment.
- *
- * Scans command directories, builds command structures, and handles both
- * global and guild-specific command deployment to Discord's API.
- *
- * @internal
- */
-declare class CommandRegistry implements Initializeable {
-    private readonly core;
-    private readonly logger;
-    private isInitialised;
-    readonly globalCommands: (SlashCommandBuilder | ContextMenuCommandBuilder)[];
-    readonly guildCommands: Collection<string, (SlashCommandBuilder | ContextMenuCommandBuilder)[]>;
-    constructor(core: Core);
-    init(): Promise<void>;
-    private loadCommands;
-    private isCommandClass;
-    private registerCommand;
-    setCommands(): Promise<void>;
-}
-
-/**
- * Discord bot implementation that manages client and controllers
- * @internal - Accessed via core.bot, not directly instantiated by users
- */
-declare class Bot extends Plugin {
-    protected core: Core;
-    readonly botToken: string;
-    readonly logger: Logger;
-    private isInitialized;
-    private readonly _client;
-    private readonly interactions;
-    private readonly events;
-    readonly commands: CommandRegistry;
-    private readonly emojiInjector;
-    /**
-     * @param core - Seedcord core instance
-     * @internal
-     */
-    constructor(core: Core);
-    /**
-     * Initializes Discord client and all controllers
-     * @internal
-     */
-    init(): Promise<void>;
-    /**
-     * Stops the bot and cleans up connections
-     * @internal
-     */
-    stop(): Promise<void>;
-    /**
-     * Logs the bot into Discord using the configured token
-     */
-    private login;
-    /**
-     * Logs out and destroys the Discord client connection
-     */
-    private logout;
-    get client(): Client;
-}
-
-/**
- * Main Seedcord bot framework class
- *
- * Primary entry point for creating Discord bots with Seedcord.
- * Manages component lifecycle and provides plugin support.
- */
-declare class Seedcord extends Pluggable implements Core {
-    readonly config: Config;
-    private static isInstantiated;
-    /** @see {@link CoordinatedShutdown} */
-    readonly shutdown: CoordinatedShutdown;
-    /** @see {@link CoordinatedStartup} */
-    readonly startup: CoordinatedStartup;
-    /** @see {@link EffectsRegistry} */
-    readonly effects: EffectsRegistry;
-    /** @see {@link Bot} */
-    readonly bot: Bot;
-    /** @see {@link HealthCheck} */
-    private readonly healthCheck;
-    /**
-     * Creates a new Seedcord instance
-     *
-     * @param config - Bot configuration including paths and Discord client options
-     * @throws An {@link Error} When attempting to create multiple instances (singleton)
-     */
-    constructor(config: Config);
-    /**
-     * Registers default startup tasks
-     * @internal
-     */
-    private registerStartupTasks;
-    /**
-     * Starts the bot and runs all initialization tasks
-     *
-     * @returns This Seedcord instance when fully initialized
-     */
-    start(): Promise<this>;
-}
-
-/** All valid Discord.js interaction types that can be handled */
-type ValidInteractionTypes = ChatInputCommandInteraction | ButtonInteraction | ModalSubmitInteraction | AutocompleteInteraction | AnySelectMenuInteraction | ContextMenuCommandInteraction;
-/** All valid Discord.js client events except interaction events */
-type ValidNonInteractionTypes = ClientEvents[Exclude<keyof ClientEvents, Events.InteractionCreate>];
-/** All event types that can be handled (interactions and client events) */
-type ValidEventTypes = ValidInteractionTypes | ValidNonInteractionTypes;
-/** Interaction types that can receive replies (excludes autocomplete) */
-type Repliables = Exclude<ValidInteractionTypes, AutocompleteInteraction>;
-/** Handler types that can reply to interactions */
-type RepliableInteractionHandler = InteractionHandler<Repliables> | InteractionMiddleware<Repliables>;
-/** Base interface for event handlers */
-interface Handler {
-    execute(): Promise<void>;
-}
-/**
- * Interface for handlers that can run pre-execution checks
- *
- * Should always accompany the `@Catchable` decorator. Will require the class to implement the `runChecks` method.
- *
- * @see {@link Checkable}
- */
-interface WithChecks {
-    /**
-     * Runs pre-execution checks for the handler.
-     *
-     * @remarks It'll be called automatically if a class is decorated with {@link Checkable} before the execute method.
-     *
-     * @virtual Override this method in your handler classes
-     */
-    runChecks(): Promise<void>;
-}
-interface HandlerWithChecks extends WithChecks, Handler {
-}
-declare abstract class BaseHandler<ValidEvent extends ValidEventTypes> implements Handler {
-    core: Core;
-    protected checkable: boolean;
-    protected break: boolean;
-    protected errored: boolean;
-    protected event: ValidEvent;
-    protected args: string[];
-    protected constructor(event: ValidEvent, core: Core, args?: string[]);
-    /**
-     * Main handler logic - implement this method to define behavior
-     * @virtual Override this method in your handler classes
-     */
-    abstract execute(): Promise<void>;
-    hasChecks(): this is HandlerWithChecks;
-    hasErrors(): boolean;
-    setErrored(): void;
-    shouldBreak(): boolean;
-    getEvent(): ValidEvent;
-    /**
-     * Gets arguments parsed from interaction customId
-     *
-     * Arguments are extracted from customId using ":" and "-" separators.
-     * For customId "accept:user123-guild456", returns ["user123", "guild456"]
-     */
-    protected getArgs(): string[];
-    /**
-     * Gets a specific argument by index from parsed customId
-     * @param index - Zero-based index of the argument to retrieve
-     * @returns The argument at the specified index, or undefined if not found
-     */
-    protected getArg(index: number): string | undefined;
-}
-/**
- * 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.
- *
- * @typeParam Repliable - The interaction type this handler processes
- */
-declare abstract class InteractionHandler<Repliable extends Repliables> extends BaseHandler<Repliable> implements Handler {
-    constructor(event: Repliable, core: Core, args?: string[]);
-}
-/**
- * Base class for interaction middleware
- *
- * Middleware runs before interaction handlers and can modify behavior or block execution.
- * Unlike handlers, middleware should not send responses directly.
- *
- * @typeParam Repliable - The interaction type this middleware processes
- */
-declare abstract class InteractionMiddleware<Repliable extends Repliables> extends BaseHandler<Repliable> implements Handler {
-    constructor(event: Repliable, core: Core, args?: string[]);
-}
-/**
- * Handler for Discord autocomplete interactions
- *
- * Extend this class to provide autocomplete suggestions for slash command options.
- * 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) */
-    protected readonly focused: AutocompleteFocusedOption;
-    constructor(event: AutocompleteInteraction, core: Core, args?: string[]);
-}
-/**
- * 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.
- *
- * @typeParam Repliable - The Discord event type this handler processes
- */
-declare abstract class EventHandler<Repliable extends keyof ClientEvents> extends BaseHandler<ClientEvents[Repliable]> implements Handler {
-    constructor(event: ClientEvents[Repliable], core: Core, args?: string[]);
-}
-/** 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>);
-/** 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>;
-
-type HandlerCtor = new (...args: any[]) => Handler;
-/**
- * Marks a handler class as requiring check execution.
- *
- * 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 **()**)
- * @decorator
- * @example
- * ```typescript
- * \@Checkable
- * class AdminCommand extends InteractionHandler {
- *   async runChecks() {
- *     // Perform admin permission checks
- *   }
- * }
- * ```
- */
-declare function Checkable<TypeHandler extends HandlerCtor>(ctor: TypeHandler): TypeHandler;
-
-/**
- * Configuration options for the Catchable decorator.
- */
-interface CatchableOptions {
-    /** Whether to log errors to console (default: false) */
-    log?: boolean;
-    /** Always use followUp instead of reply/editReply (default: false) */
-    forceFollowup?: boolean;
-}
-/**
- * Catches and handles errors in interaction handler methods
- *
- * Automatically sends error responses to users and prevents uncaught exceptions.
- * Should be applied to the execute() or runChecks() methods of interaction handlers.
- *
- * @param options - Configuration for error handling behavior
- * @decorator
- * @example
- * ```typescript
- * class MyHandler extends InteractionHandler {
- *   \@Catchable({ log: true })
- *   async execute() {
- *     // method implementation
- *   }
- * }
- * ```
- */
-declare function Catchable(options?: CatchableOptions): (_target: RepliableInteractionHandler, _propertyKey: string, descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<void>>) => void;
-
-declare const BuilderTypes: {
-    command: typeof SlashCommandBuilder;
-    embed: typeof EmbedBuilder;
-    button: typeof ButtonBuilder;
-    menu_string: typeof StringSelectMenuBuilder;
-    menu_option_string: typeof StringSelectMenuOptionBuilder;
-    menu_user: typeof UserSelectMenuBuilder;
-    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;
-    media: typeof MediaGalleryBuilder;
-    section: typeof SectionBuilder;
-    separator: typeof SeparatorBuilder;
-};
-declare const RowTypes: {
-    button: typeof ActionRowBuilder<ButtonBuilder>;
-    menu_string: typeof ActionRowBuilder<StringSelectMenuBuilder>;
-    menu_user: typeof ActionRowBuilder<UserSelectMenuBuilder>;
-    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;
-};
-type BuilderType = keyof typeof BuilderTypes;
-type InstantiatedBuilder<BuilderKey extends BuilderType> = InstanceType<(typeof BuilderTypes)[BuilderKey]>;
-type ActionRowComponentType = keyof typeof RowTypes;
-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
- */
-declare abstract class BaseComponent<TComponent> {
-    private readonly _component;
-    protected constructor(ComponentClass: new () => TComponent);
-    /**
-     * Gets the built component (should be considered read-only)
-     *
-     * Returns the finalized component ready for use in Discord messages.
-     *
-     * Please do not use for further configuration, use `this.instance` for that.
-     * @example new SomeComponent().component
-     */
-    abstract get component(): InstantiatedBuilder<BuilderType> | InstantiatedActionRow<ActionRowComponentType>;
-    /**
-     * Gets the component instance for configuration
-     *
-     * Use this to access Discord.js builder methods like setTitle(), setDescription(), etc.
-     *
-     * Use this in your component classes to configure the builder
-     * @example this.instance.setTitle('My Modal')
-     */
-    protected get instance(): TComponent;
-    /**
-     * Builds a customId string for interactive components
-     *
-     * 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
-     * @param args - Additional arguments to encode in the customId
-     * @returns Formatted customId string
-     */
-    buildCustomId(prefix: string, ...args: string[]): string;
-}
-/**
- * Base class for Discord.js builder components
- *
- * Wraps Discord.js builders (SlashCommandBuilder, EmbedBuilder, etc.) with
- * Seedcord-specific defaults and helper methods.
- *
- * @typeParam BuilderKey - The type of Discord.js builder being wrapped
- */
-declare abstract class BuilderComponent<BuilderKey extends BuilderType> extends BaseComponent<InstantiatedBuilder<BuilderKey>> {
-    private readonly botColor;
-    protected constructor(type: BuilderKey);
-    get component(): InstantiatedBuilder<BuilderKey>;
-}
-/**
- * Base class for Discord action row components
- *
- * Wraps Discord.js action row builder with Seedcord-specific defaults and helper methods.
- *
- * @typeParam RowKey - The Discord.js action row type being wrapped
- */
-declare abstract class RowComponent<RowKey extends ActionRowComponentType> extends BaseComponent<InstantiatedActionRow<RowKey>> {
-    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
- *
- * This is bundled in {@link CustomError}s as the response.
- */
-declare class BaseErrorEmbed extends BuilderComponent<'embed'> {
-    /**
-     * Creates a new error embed with default configuration.
-     */
-    constructor();
-}
-/**
- * Base class for custom error types with Discord embed responses
- *
- * Errors extending CustomError should be used with the `Catchable` decorators to implement a control flow. These errors will be caught and handled by the framework to show the user the configured response.
- */
-declare abstract class CustomError extends Error {
-    message: string;
-    private _emit;
-    readonly response: EmbedBuilder;
-    protected constructor(message: string);
-    /**
-     * Whether this error should be emitted to logs
-     *
-     * Controls logging behavior. Errors with emit=true will always be logged,
-     * while emit=false errors may be suppressed in production.
-     *
-     * @returns True if the error should be logged
-     */
-    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;
-
-declare const CommandMetadataKey: unique symbol;
-type CommandCtor = new (...args: any[]) => BuilderComponent<'command' | 'context_menu'>;
-/**
- * Metadata for global command registration.
- */
-interface GlobalMeta {
-    scope: 'global';
-}
-/**
- * Metadata for guild-specific command registration.
- */
-interface GuildMeta {
-    scope: 'guild';
-    guilds: string[];
-}
-/**
- * Union type for command registration metadata.
- */
-type CommandMeta = GlobalMeta | GuildMeta;
-/**
- * Registers a command for global deployment.
- *
- * @param scope - Must be 'global' for global registration
- * @decorator
- * @example
- * ```typescript
- * \@RegisterCommand('global')
- * class PingCommand extends BuilderComponent {
- *   // Global command
- * }
- * ```
- */
-declare function RegisterCommand(scope: 'global'): (ctor: CommandCtor) => void;
-/**
- * Registers a command for specific guild deployment.
- *
- * @param scope - Must be 'guild' for guild-specific registration
- * @param guilds - Array of guild IDs where the command should be registered
- * @decorator
- * @example
- * ```typescript
- * \@RegisterCommand('guild', ['123456789'])
- * class AdminCommand extends BuilderComponent {
- *   // Guild-specific command
- * }
- * ```
- */
-declare function RegisterCommand(scope: 'guild', guilds: string[]): (ctor: CommandCtor) => void;
-
-/**
- * Catches and handles errors in event handler methods.
- *
- * 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)
- * @decorator
- * @example
- * ```typescript
- * class MessageHandler extends EventHandler {
- *   \@EventCatchable(true)
- *   async execute() {
- *     // Event handling logic
- *   }
- * }
- * ```
- */
-declare function EventCatchable(log?: boolean): (_target: EventHandler<keyof ClientEvents>, _prop: string, descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<void>>) => void;
-
-declare const EventMetadataKey: unique symbol;
-/**
- * Registers an event handler class with a specific Discord.js event.
- *
- * Associates the decorated class with a Discord client event for automatic
- * registration and execution when the event is emitted.
- *
- * @param eventName - The Discord.js event name to listen for
- * @decorator
- * @example
- * ```typescript
- * \@RegisterEvent(Events.MessageCreate)
- * class MessageHandler extends EventHandler<Events.MessageCreate> {
- *   async execute() {
- *     // Handle message creation
- *   }
- * }
- * ```
- */
-declare function RegisterEvent<KeyofEvents extends keyof ClientEvents>(eventName: KeyofEvents): (constructor: ConstructorFunction) => void;
-
-declare enum InteractionRoutes {
-    Slash = "interaction:slash",
-    Button = "interaction:button",
-    Modal = "interaction:modal",
-    StringMenu = "interaction:stringMenu",
-    UserMenu = "interaction:userMenu",
-    RoleMenu = "interaction:roleMenu",
-    ChannelMenu = "interaction:channelMenu",
-    MentionableMenu = "interaction:mentionableMenu",
-    MessageContextMenu = "interaction:messageContextMenu",
-    UserContextMenu = "interaction:userContextMenu",
-    Autocomplete = "interaction:autocomplete"
-}
-declare enum SelectMenuType {
-    String = "string",
-    User = "user",
-    Role = "role",
-    Channel = "channel",
-    Mentionable = "mentionable"
-}
-declare const InteractionMetadataKey: unique symbol;
-/**
- * Routes slash commands to handler classes
- *
- * Supports single commands, subcommands, and subcommand groups.
- * Use forward slashes to separate subcommand paths.
- *
- * @param routeOrRoutes - Command path(s) to handle
- * @decorator
- * @example
- * ```typescript
- * \@SlashRoute('ping')
- * class PingCommand extends InteractionHandler {
- *   // handles /ping command
- * }
- *
- * \@SlashRoute(['ban', 'kick'])
- * class ModerationHandler extends InteractionHandler {
- *   // handles /ban and /kick commands
- * }
- *
- * \@SlashRoute('admin/user/promote')
- * class PromoteHandler extends InteractionHandler {
- *   // handles /admin user promote subcommand
- * }
- * ```
- */
-declare function SlashRoute(routeOrRoutes: string | string[]): (constructor: ConstructorFunction) => void;
-/**
- * Routes button interactions to handler classes
- *
- * Matches the customId prefix before the first colon.
- * For customId "accept:user123", use \@ButtonRoute("accept").
- *
- * @param routeOrRoutes - CustomId prefix(es) to handle
- * @decorator
- */
-declare function ButtonRoute(routeOrRoutes: string | string[]): (constructor: ConstructorFunction) => void;
-/**
- * Routes modal submissions to handler classes
- *
- * Matches the customId prefix before the first colon.
- *
- * @param routeOrRoutes - CustomId prefix(es) to handle
- * @decorator
- */
-declare function ModalRoute(routeOrRoutes: string | string[]): (constructor: ConstructorFunction) => void;
-/**
- * Routes context menu commands to handler classes
- *
- * @param type - Context menu type: 'message' for message context menus, 'user' for user context menus
- * @param routeOrRoutes - Command name(s) to handle
- * @decorator
- */
-declare function ContextMenuRoute(type: 'message' | 'user', routeOrRoutes: string | string[]): (constructor: ConstructorFunction) => void;
-/**
- * Routes autocomplete interactions to handler classes
- *
- * Handles autocomplete requests for specific command options.
- * Creates routes for each command-field combination.
- *
- * @param commandRoutes - Command path(s) to handle
- * @param focusedFields - Option name(s) to provide completions for
- * @example \@AutocompleteRoute('user', 'name') // Single command, single field
- * @example \@AutocompleteRoute(['user', 'profile'], ['name', 'bio']) // Multiple commands, multiple fields
- * @decorator
- */
-declare function AutocompleteRoute(commandRoutes: string | string[], focusedFields: string | string[]): (constructor: ConstructorFunction) => void;
-/**
- * Routes select menu interactions to handler classes
- *
- * Matches the customId prefix before the first colon.
- *
- * @param type - Select menu type from {@link SelectMenuType}
- * @param routeOrRoutes - CustomId prefix(es) to handle
- * @decorator
- */
-declare function SelectMenuRoute(type: SelectMenuType, routeOrRoutes: string | string[]): (constructor: ConstructorFunction) => void;
-
-/**
- * Throws a custom error with a formatted message and optional UUID.
- *
- * 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
- * @param error - The original error or value
- * @param message - Custom message to include
- * @param CustomError - Error class to instantiate and throw
- * @throws Instance of the provided {@link CustomError} subclass
- *
- * @example
- * ```typescript
- * try {
- *   // risky code
- * } catch (e) {
- *   throwCustomError(e, "Something went wrong", MyCustomError);
- * }
- * ```
- */
-declare function throwCustomError<Ctor extends CustomErrorConstructor>(error: unknown, message: string, CustomError: Ctor): never;
-
-/**
- * Type-safe event emitter for application effects.
- *
- * Provides a strongly-typed wrapper around Node.js EventEmitter
- * for Seedcord's effect system.
- *
- * @typeParam AllEffects - Side effect definitions mapping event names to data types
- */
-declare class EffectsEmitter {
-    private readonly emitter;
-    /**
-     * Registers a listener for the specified side effect.
-     *
-     * @typeParam KeyOfEffects - The side effect name type
-     * @param event - The side effect name to listen for
-     * @param listener - Function to call when the event is emitted
-     * @returns This EffectsEmitter instance for chaining
-     */
-    on<KeyOfEffects extends EffectKeys>(event: KeyOfEffects, listener: (data: AllEffects[KeyOfEffects]) => void): this;
-    /**
-     * Registers a one-time listener for the specified side effect.
-     *
-     * @typeParam KeyOfEffects - The side effect name type
-     * @param event - The side effect name to listen for once
-     * @param listener - Function to call when the event is emitted
-     * @returns This EffectsEmitter instance for chaining
-     */
-    once<KeyOfEffects extends EffectKeys>(event: KeyOfEffects, listener: (data: AllEffects[KeyOfEffects]) => void): this;
-    /**
-     * Emits a side effect with the provided data.
-     *
-     * @typeParam KeyOfEffects - The side effect name type
-     * @param event - The side effect name to emit
-     * @param data - The data to pass to registered listeners
-     * @returns True if the event had listeners, false otherwise
-     */
-    emit<KeyOfEffects extends EffectKeys>(event: KeyOfEffects, data: AllEffects[KeyOfEffects]): boolean;
-}
-
-declare const EffectMetadataKey: unique symbol;
-/**
- * Registers a side effect handler class with a specific side effect event.
- *
- * Associates the decorated class with a side effect event type for automatic
- * registration and execution when the side effect is emitted.
- *
- * @param effect - The side effect event name to register for
- * @decorator
- * @example
- * ```typescript
- * \@RegisterEffect('userJoin')
- * class WelcomeHandler extends EffectHandler<'userJoin'> {
- *   async execute() {
- *     // Handle user join event
- *   }
- * }
- * ```
- */
-declare function RegisterEffect<TEffect extends EffectKeys>(effect: TEffect): (constructor: ConstructorFunction) => void;
-
-/**
- * Abstract base class for handling application side effects.
- *
- * Provides type-safe access to effects data and the core framework instance.
- * Extend this class to create custom side effect handlers.
- *
- * @typeParam KeyOfEffects - The specific side effect type this handler processes
- */
-declare abstract class EffectsHandler<KeyOfEffects extends EffectKeys> {
-    protected readonly data: AllEffects[KeyOfEffects];
-    protected readonly core: Core;
-    /**
-     * Creates a new effects handler instance.
-     *
-     * @param data - The effect event data
-     * @param core - The core framework instance
-     */
-    constructor(data: AllEffects[KeyOfEffects], core: Core);
-    /**
-     * Executes the effect handler logic.
-     * @virtual Override this method in your handler classes
-     */
-    abstract execute(): Promise<void>;
-}
-
-/**
- * Abstract webhook logging handler for side effect events.
- *
- * Extends EffectsHandler to provide webhook-based logging capabilities.
- * Implementations must define the webhook client to send messages to.
- *
- * @typeParam KeyOfEffects - The specific side effect type this handler processes
- */
-declare abstract class WebhookLog<KeyOfEffects extends EffectKeys> extends EffectsHandler<KeyOfEffects> {
-    /** The Discord webhook client for sending log messages */
-    abstract webhook: WebhookClient;
-    constructor(data: AllEffects[KeyOfEffects], core: Core);
-}
-
-/**
- * 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);
-}
-
-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 };