commandkit 1.0.0-dev.20250529125116 → 1.0.0-dev.20250530015910

package/dist/CommandKit-jZCy9fZX.d.ts

@@ -1,914 +0,0 @@
-import * as discord_js from 'discord.js';
-import { RESTPostAPIApplicationCommandsJSONBody, Client, Interaction, CacheType, ChatInputCommandInteraction, MessageContextMenuCommandInteraction, UserContextMenuCommandInteraction, AutocompleteInteraction, Message, Guild, TextBasedChannel, Locale, Awaitable, SlashCommandBuilder, Collection, ContextMenuCommandBuilder, ContextMenuCommandInteraction, ClientEvents } from 'discord.js';
-import EventEmitter from 'node:events';
-import { jsx as createElement, Fragment } from './components/common/element.js';
-import { EventInterceptor } from './components/common/EventInterceptor.js';
-import { MessageCommandParser, MessageCommandOptions } from './app/commands/MessageCommandParser.js';
-import { Command, Middleware, CommandsRouter } from './app/router/CommandsRouter.js';
-import { ParsedEvent, EventsRouter } from './app/router/EventsRouter.js';
-import { OnLoadArgs, Loader, OnResolveArgs, Setup } from './plugins/plugin-runtime/types.js';
-import { HMREventType } from './utils/constants.js';
-
-/**
- * Options for instantiating a CommandKit handler.
- */
-interface CommandKitOptions {
-    /**
-     * The Discord.js client object to use with CommandKit.
-     */
-    client: Client;
-}
-/**
- * Represents a command context.
- */
-interface CommandContext<T extends Interaction, Cached extends CacheType> {
-    /**
-     * The interaction that triggered this command.
-     */
-    interaction: Interaction<CacheType>;
-    /**
-     * The client that instantiated this command.
-     */
-    client: Client;
-    /**
-     * The command data.
-     */
-    handler: CommandKit;
-}
-type CommandData = RESTPostAPIApplicationCommandsJSONBody & {
-    guilds?: string[];
-};
-
-type GenericFunction<A extends any[] = any[]> = (...args: A) => any;
-declare function isCommandWorkerContext(worker: any): worker is CommandKitEnvironment;
-/**
- * Represents an async function that can be cached
- * @template R - Array of argument types
- * @template T - Return type
- */
-type AsyncFunction<R extends any[] = any[], T = any> = (...args: R) => Promise<T>;
-declare function exitContext<T>(fn: () => T): T;
-declare function provideContext<R>(value: CommandKitEnvironment, receiver: () => R): R;
-/**
- * Returns a context-aware version of the given function.
- * @param env - The commandkit environment data.
- * @param fn - The target function.
- * @param finalizer - An optional finalizer function to run after the target function. This function will be context-aware.
- * @internal
- */
-declare function makeContextAwareFunction<R extends GenericFunction, F extends GenericFunction>(env: CommandKitEnvironment, fn: R, finalizer?: F): R;
-/**
- * Retrieves commandkit
- * @private
- * @internal
- */
-declare function getCommandKit(): CommandKit | undefined;
-declare function getCommandKit(strict: true): CommandKit;
-declare function getCommandKit(strict: false): CommandKit | undefined;
-/**
- * Get the current commandkit context.
- * @internal
- */
-declare function getContext(): CommandKitEnvironment | undefined;
-/**
- * Use current commandkit context. Throws an error if no context is found.
- */
-declare function useEnvironment(): CommandKitEnvironment;
-
-interface PreRegisterCommandsEvent {
-    preventDefault(): void;
-    commands: CommandData[];
-}
-declare class CommandRegistrar {
-    readonly commandkit: CommandKit;
-    private api;
-    /**
-     * Creates an instance of CommandRegistrar.
-     * @param commandkit The commandkit instance.
-     */
-    constructor(commandkit: CommandKit);
-    /**
-     * Gets the commands data.
-     */
-    getCommandsData(): CommandData[];
-    /**
-     * Registers loaded commands.
-     */
-    register(): Promise<void>;
-    /**
-     * Updates the global commands.
-     */
-    updateGlobalCommands(commands: CommandData[]): Promise<void>;
-    /**
-     * Updates the guild commands.
-     */
-    updateGuildCommands(commands: CommandData[]): Promise<void>;
-}
-
-interface CommandKitEnvironmentInternalData {
-    executionError: Error | null;
-    type: CommandKitEnvironmentType | null;
-    variables: Map<string, any>;
-    deferredFunctions: Map<string, GenericFunction<[CommandKitEnvironment]>>;
-    marker: string;
-    markStart: number;
-    markEnd: number;
-    context: Context | null;
-}
-declare class CommandKitEnvironment {
-    #private;
-    readonly commandkit: CommandKit;
-    /**
-     * Creates the commandkit execution environment.
-     * @param commandkit - The commandkit instance.
-     */
-    constructor(commandkit: CommandKit);
-    /**
-     * Set the context.
-     * @param context - The context to set.
-     */
-    setContext(context: Context): void;
-    /**
-     * Get the context. `null` if not set.
-     * @internal
-     */
-    get context(): Context | null;
-    /**
-     * Get the execution error.
-     * @internal
-     */
-    getExecutionError(): Error | null;
-    /**
-     * Set the execution error.
-     * @param error - The error to set.
-     * @internal
-     */
-    setExecutionError(error: Error): void;
-    /**
-     * Get the environment type.
-     */
-    getType(): CommandKitEnvironmentType;
-    /**
-     * Set the environment type.
-     * @param type - The environment type to set.
-     * @internal
-     */
-    setType(type: CommandKitEnvironmentType): void;
-    /**
-     * The variables store for this environment.
-     */
-    get variables(): Map<string, any>;
-    /**
-     * Register a deferred function.
-     * @param fn - The deferred function to register.
-     * @returns The deferred function id.
-     * @internal
-     */
-    registerDeferredFunction(fn: GenericFunction<[CommandKitEnvironment]>): string;
-    /**
-     * Clear a deferred function by id.
-     * @param id - The deferred function id to clear.
-     * @internal
-     */
-    clearDeferredFunction(id: string): void;
-    /**
-     * Run all deferred functions sequentially.
-     * @internal
-     */
-    runDeferredFunctions(): Promise<void>;
-    /**
-     * Clear all deferred functions.
-     * @internal
-     */
-    clearAllDeferredFunctions(): void;
-    /**
-     * Mark the start of a command execution.
-     * @param marker - The marker to set.
-     * @internal
-     */
-    markStart(marker: string): void;
-    /**
-     * Mark the end of a command execution.
-     * @internal
-     */
-    markEnd(): void;
-    /**
-     * Get the marker.
-     * @internal
-     */
-    getMarker(): string;
-    /**
-     * Get the execution time in milliseconds.
-     * @internal
-     */
-    getExecutionTime(): number;
-}
-declare enum CommandKitEnvironmentType {
-    CommandHandler = "COMMAND_HANDLER"
-}
-/**
- * Runs the given function after the current command has finished executing.
- * @param fn The function to run after the current command.
- * @returns The deferred function id. This can be used to cancel the deferred function.
- */
-declare function after(fn: GenericFunction<[CommandKitEnvironment]>): string;
-/**
- * Cancels a deferred function registered with `after`.
- * @param id The deferred function id to cancel.
- */
-declare function cancelAfter(id: string): void;
-
-declare const CommandExecutionMode: {
-    readonly ChatInputCommand: "chatInput";
-    readonly MessageContextMenu: "messageContextMenu";
-    readonly UserContextMenu: "userContextMenu";
-    readonly Autocomplete: "autocomplete";
-    readonly Message: "message";
-};
-type CommandExecutionMode = (typeof CommandExecutionMode)[keyof typeof CommandExecutionMode];
-interface ContextParameters<T extends CommandExecutionMode, Args = Record<string, any>> {
-    command: LoadedCommand;
-    environment?: CommandKitEnvironment;
-    executionMode: T;
-    interaction: T extends 'chatInput' ? ChatInputCommandInteraction : T extends 'messageContextMenu' ? MessageContextMenuCommandInteraction : T extends 'userContextMenu' ? UserContextMenuCommandInteraction : T extends 'autocomplete' ? AutocompleteInteraction : never;
-    message: T extends 'message' ? Message : never;
-    forwarded?: boolean;
-    messageCommandParser?: T extends 'message' ? MessageCommandParser : never;
-    store?: Map<string, any>;
-    customArgs?: Args;
-}
-type MessageCommandContext = Context<'message'>;
-type InteractionCommandContext = Context<'autocomplete' | 'chatInput' | 'messageContextMenu' | 'userContextMenu'>;
-type MessageCommandMiddlewareContext = MiddlewareContext<'message'>;
-type InteractionCommandMiddlewareContext = MiddlewareContext<'autocomplete' | 'chatInput' | 'messageContextMenu' | 'userContextMenu'>;
-type ChatInputCommandContext = Context<'chatInput'>;
-type SlashCommandMiddlewareContext = MiddlewareContext<'chatInput'>;
-type AutocompleteCommandContext = Context<'autocomplete'>;
-type AutocompleteCommandMiddlewareContext = MiddlewareContext<'autocomplete'>;
-type MessageContextMenuCommandContext = Context<'messageContextMenu'>;
-type MessageContextMenuCommandMiddlewareContext = MiddlewareContext<'messageContextMenu'>;
-type UserContextMenuCommandContext = Context<'userContextMenu'>;
-type UserContextMenuCommandMiddlewareContext = MiddlewareContext<'userContextMenu'>;
-type CommandContextOptions<T extends CommandExecutionMode> = T extends 'message' ? MessageCommandOptions : T extends 'chatInput' ? ChatInputCommandInteraction['options'] : T extends 'autocomplete' ? AutocompleteInteraction['options'] : T extends 'messageContextMenu' ? MessageContextMenuCommandInteraction['options'] : T extends 'userContextMenu' ? UserContextMenuCommandInteraction['options'] : never;
-type AnyCommandExecute<ContextType extends Context = Context> = (ctx: ContextType) => Awaitable<unknown>;
-type ChatInputCommand = AnyCommandExecute<ChatInputCommandContext>;
-type AutocompleteCommand = AnyCommandExecute<AutocompleteCommandContext>;
-type MessageContextMenuCommand = AnyCommandExecute<MessageContextMenuCommandContext>;
-type UserContextMenuCommand = AnyCommandExecute<UserContextMenuCommandContext>;
-type MessageCommand = AnyCommandExecute<MessageCommandContext>;
-interface MiddlewareContextArgs {
-    setCommandRunner?: GenericFunction<[RunCommand]>;
-}
-declare class Context<ExecutionMode extends CommandExecutionMode = CommandExecutionMode, Args extends Record<string, any> = Record<string, any>> {
-    #private;
-    readonly commandkit: CommandKit;
-    protected readonly config: ContextParameters<ExecutionMode, Args>;
-    /**
-     * The interaction that triggered the command.
-     */
-    readonly interaction: ContextParameters<ExecutionMode>['interaction'];
-    /**
-     * The message that triggered the command.
-     */
-    readonly message: ContextParameters<ExecutionMode>['message'];
-    /**
-     * The guild where the command was triggered.
-     */
-    readonly guild: Guild | null;
-    /**
-     * The guild ID where the command was triggered.
-     */
-    readonly guildId: string | null;
-    /**
-     * The channel where the command was triggered.
-     */
-    readonly channel: TextBasedChannel | null;
-    /**
-     * The channel id where the command was triggered.
-     */
-    readonly channelId: string | null;
-    /**
-     * The client instance.
-     */
-    readonly client: Client;
-    /**
-     * The command that this context belongs to.
-     */
-    readonly command: LoadedCommand;
-    private _locale;
-    /**
-     * Creates a new command context.
-     * @param commandkit The command kit instance.
-     * @param config The context parameters.
-     */
-    constructor(commandkit: CommandKit, config: ContextParameters<ExecutionMode, Args>);
-    /**
-     * The shared key-value store for this context. This can be used to store data that needs to be shared between middlewares or commands.
-     * This store is shared across all contexts in the same command execution, including the cloned contexts and middleware contexts.
-     */
-    get store(): Map<string, any>;
-    get commandName(): string;
-    get options(): CommandContextOptions<ExecutionMode>;
-    /**
-     * Whether this context was forwarded from another context. This happens when a command forwards its context to another command.
-     */
-    get forwarded(): boolean;
-    /**
-     * Forwards the context to another command. The target handler will be the same as current handler.
-     * @param command The command to forward to.
-     */
-    forwardCommand<C extends ResolvableCommand>(command: C): Promise<never>;
-    /**
-     * The execution mode of the command.
-     */
-    get executionMode(): ExecutionMode;
-    /**
-     * Whether the command was triggered by an interaction.
-     */
-    isInteraction(): this is InteractionCommandContext;
-    /**
-     * Whether the command was triggered by a slash command interaction.
-     */
-    isChatInputCommand(): this is ChatInputCommandContext;
-    /**
-     * Whether the command was triggered by an autocomplete interaction.
-     */
-    isAutocomplete(): this is AutocompleteCommandContext;
-    /**
-     * Whether the command was triggered by a message context menu interaction.
-     */
-    isMessageContextMenu(): this is MessageContextMenuCommandContext;
-    /**
-     * Whether the command was triggered by a user context menu interaction.
-     */
-    isUserContextMenu(): this is UserContextMenuCommandContext;
-    /**
-     * Whether the command was triggered by a message.
-     */
-    isMessage(): this is Context<'message'>;
-    /**
-     * Returns the command identifier.
-     */
-    getCommandIdentifier(): string;
-    /**
-     * Returns the locale of the guild where this command was triggered.
-     */
-    getGuildLocale(): Locale | null;
-    /**
-     * Returns the locale of the user who triggered this command.
-     */
-    getUserLocale(): Locale | null;
-    /**
-     * Returns the locale for this command.
-     * @param preferUser Whether to prefer the user's locale over the guild's locale.
-     * @returns The locale for this command. If no locale is found, the default locale is returned.
-     */
-    getLocale(preferUser?: boolean): Locale;
-    /**
-     * Sets the locale for this command.
-     * @param locale The locale to set.
-     */
-    setLocale(locale: Locale | null): void;
-    /**
-     * Creates a clone of this context
-     */
-    clone(config?: Partial<ContextParameters<ExecutionMode>>): Context<ExecutionMode>;
-    isMiddleware(): this is MiddlewareContext<ExecutionMode>;
-    args(): string[];
-    /**
-     * Stops upcoming middleware or current command execution.
-     * If this is called inside pre-stage middleware, the next run will be the actual command, skipping all other pre-stage middlewares.
-     * If this is called inside a command itself, it will skip all post-stage middlewares.
-     * If this is called inside post-stage middleware, it will skip all other post-stage middlewares.
-     */
-    exit(): never;
-}
-declare class MiddlewareContext<T extends CommandExecutionMode = CommandExecutionMode> extends Context<T, MiddlewareContextArgs> {
-    #private;
-    /**
-     * Whether the command execution was cancelled.
-     */
-    get cancelled(): boolean;
-    /**
-     * Cancels the command execution.
-     */
-    cancel(): void;
-    /**
-     * Sets command runner function to wrap the command execution.
-     * @param fn The function to set.
-     * @example ctx.setCommandRunner(async (execute) => {
-     *  // do something before command execution
-     *  await execute();
-     *  // do something after command execution
-     * })
-     */
-    setCommandRunner(fn: RunCommand): void;
-}
-
-declare class AppCommandRunner {
-    #private;
-    private handler;
-    constructor(handler: AppCommandHandler);
-    runCommand(prepared: PreparedAppCommandExecution, source: Interaction | Message): Promise<void>;
-    getExecutionMode(source: Interaction | Message): CommandExecutionMode;
-}
-
-type RunCommand = <T extends AsyncFunction>(fn: T) => T;
-interface AppCommand {
-    command: SlashCommandBuilder | Record<string, any>;
-    chatInput?: (ctx: Context) => Awaitable<unknown>;
-    autocomplete?: (ctx: Context) => Awaitable<unknown>;
-    message?: (ctx: Context) => Awaitable<unknown>;
-    messageContextMenu?: (ctx: Context) => Awaitable<unknown>;
-    userContextMenu?: (ctx: Context) => Awaitable<unknown>;
-}
-interface AppCommandMiddleware {
-    beforeExecute: (ctx: Context) => Awaitable<unknown>;
-    afterExecute: (ctx: Context) => Awaitable<unknown>;
-}
-interface LoadedCommand {
-    command: Command;
-    data: AppCommand;
-    guilds?: string[];
-}
-type CommandTypeData = string;
-type ResolvableCommand = CommandTypeData | (string & {});
-interface LoadedMiddleware {
-    middleware: Middleware;
-    data: AppCommandMiddleware;
-}
-interface PreparedAppCommandExecution {
-    command: LoadedCommand;
-    middlewares: LoadedMiddleware[];
-    messageCommandParser?: MessageCommandParser;
-}
-type CommandBuilderLike = SlashCommandBuilder | ContextMenuCommandBuilder | Record<string, any>;
-declare class AppCommandHandler {
-    readonly commandkit: CommandKit;
-    private loadedCommands;
-    private loadedMiddlewares;
-    private commandNameToId;
-    private subcommandPathToId;
-    readonly registrar: CommandRegistrar;
-    private onInteraction;
-    private onMessageCreate;
-    readonly commandRunner: AppCommandRunner;
-    readonly externalCommandData: Collection<string, Command>;
-    readonly externalMiddlewareData: Collection<string, Middleware>;
-    constructor(commandkit: CommandKit);
-    printBanner(): void;
-    getCommandsArray(): LoadedCommand[];
-    registerCommandHandler(): void;
-    prepareCommandRun(source: Interaction | Message, cmdName?: string): Promise<PreparedAppCommandExecution | null>;
-    reloadCommands(): Promise<void>;
-    addExternalMiddleware(data: Middleware[]): Promise<void>;
-    addExternalCommands(data: Command[]): Promise<void>;
-    registerExternalLoadedMiddleware(data: LoadedMiddleware[]): Promise<void>;
-    registerExternalLoadedCommands(data: LoadedCommand[]): Promise<void>;
-    loadCommands(): Promise<void>;
-    private loadMiddleware;
-    private loadCommand;
-}
-
-type ListenerFunction = GenericFunction | AsyncFunction;
-declare class CommandKitEventsChannel {
-    readonly commandkit: CommandKit;
-    private emitter;
-    constructor(commandkit: CommandKit);
-    to(namespace: string): {
-        on: (event: string, listener: ListenerFunction) => void;
-        off: (event: string, listener: ListenerFunction) => void;
-        once: (event: string, listener: ListenerFunction) => void;
-        emit: (event: string, ...args: any[]) => boolean;
-        removeAllListeners: (event: string) => void;
-    };
-    on(namespace: string, event: string, listener: ListenerFunction): void;
-    off(namespace: string, event: string, listener: ListenerFunction): void;
-    once(namespace: string, event: string, listener: ListenerFunction): void;
-    emit(namespace: string, event: string, ...args: any[]): boolean;
-    removeAllListeners(namespace: string): void;
-    removeAllListeners(namespace: string, event: string): void;
-}
-
-type EventListener = {
-    handler: ListenerFunction;
-    once: boolean;
-};
-interface LoadedEvent {
-    name: string;
-    namespace: string | null;
-    event: ParsedEvent;
-    listeners: EventListener[];
-    mainListener?: EventListener;
-    executedOnceListeners?: Set<ListenerFunction>;
-}
-interface AppEventsHandlerLoadedData {
-    name: string;
-    namespace: string | null;
-    onceListeners: number;
-    regularListeners: number;
-    metadata: ParsedEvent;
-}
-declare class AppEventsHandler {
-    readonly commandkit: CommandKit;
-    private loadedEvents;
-    constructor(commandkit: CommandKit);
-    getEvents(): AppEventsHandlerLoadedData[];
-    reloadEvents(): Promise<void>;
-    loadEvents(): Promise<void>;
-    unregisterAll(): void;
-    registerAllClientEvents(): void;
-    unregisterAllClientListeners(): void;
-}
-
-interface CommandKitHMREvent {
-    event: HMREventType;
-    path: string;
-    accept: () => void;
-    preventDefault: () => void;
-}
-declare function registerDevHooks(commandkit: CommandKit): void;
-
-declare abstract class RuntimePlugin<T extends PluginOptions = PluginOptions> extends PluginCommon<T, CommandKitPluginRuntime> {
-    readonly type = PluginType.Runtime;
-    /**
-     * Called before commands are loaded
-     */
-    onBeforeCommandsLoad(ctx: CommandKitPluginRuntime): Promise<void>;
-    /**
-     * Called after commands are loaded
-     */
-    onAfterCommandsLoad(ctx: CommandKitPluginRuntime): Promise<void>;
-    /**
-     * Called before events are loaded
-     */
-    onBeforeEventsLoad(ctx: CommandKitPluginRuntime): Promise<void>;
-    /**
-     * Called after events are loaded
-     */
-    onAfterEventsLoad(ctx: CommandKitPluginRuntime): Promise<void>;
-    /**
-     * Called before the client logs in
-     */
-    onBeforeClientLogin(ctx: CommandKitPluginRuntime): Promise<void>;
-    /**
-     * Called after the client logs in
-     */
-    onAfterClientLogin(ctx: CommandKitPluginRuntime): Promise<void>;
-    /**
-     * Called before interaction is handled
-     * @param interaction The interaction
-     */
-    onBeforeInteraction(ctx: CommandKitPluginRuntime, interaction: Interaction): Promise<void>;
-    /**
-     * Called before message command is processed
-     * @param message The message
-     */
-    onBeforeMessageCommand(ctx: CommandKitPluginRuntime, message: Message): Promise<void>;
-    /**
-     * Called before command is executed. This method can execute the command itself.
-     * @param source The source that triggered the command
-     * @param command The command
-     * @param execute The function that executes the command
-     */
-    executeCommand(ctx: CommandKitPluginRuntime, env: CommandKitEnvironment, source: Interaction | Message, command: PreparedAppCommandExecution, execute: () => Promise<any>): Promise<boolean>;
-    /**
-     * Called after events router is initialized
-     * @param ctx The context
-     */
-    onEventsRouterInit(ctx: CommandKitPluginRuntime): Promise<void>;
-    /**
-     * Called after commands router is initialized
-     * @param ctx The context
-     */
-    onCommandsRouterInit(ctx: CommandKitPluginRuntime): Promise<void>;
-    /**
-     * Called when HMR event is received
-     * @param ctx The context
-     * @param event The event
-     */
-    performHMR(ctx: CommandKitPluginRuntime, event: CommandKitHMREvent): Promise<void>;
-    /**
-     * Called before command is loaded for registration. This method can be used to modify the command data before it is loaded.
-     * @param ctx The context
-     * @param commands The command that is being loaded. This is a CommandBuilderLike object which represents Discord's command
-     */
-    prepareCommand(ctx: CommandKitPluginRuntime, commands: CommandBuilderLike): Promise<CommandBuilderLike | null>;
-    /**
-     * Called before command is registered to discord. This method can cancel the registration of the command and handle it manually.
-     * @param ctx The context
-     * @param data The command registration data
-     */
-    onBeforeRegisterCommands(ctx: CommandKitPluginRuntime, event: PreRegisterCommandsEvent): Promise<void>;
-    /**
-     * Called before global commands registration. This method can cancel the registration of the command and handle it manually.
-     * This method is called after `onBeforeRegisterCommands` if that stage was not handled.
-     * @param ctx The context
-     * @param event The command registration data
-     */
-    onBeforeRegisterGlobalCommands(ctx: CommandKitPluginRuntime, event: PreRegisterCommandsEvent): Promise<void>;
-    /**
-     * Called before guild commands registration. This method can cancel the registration of the command and handle it manually.
-     * This method is called before guilds of the command are resolved. It is called after `onBeforeRegisterCommands` if that stage was not handled.
-     * @param ctx The context
-     * @param event The command registration data
-     */
-    onBeforePrepareGuildCommandsRegistration(ctx: CommandKitPluginRuntime, event: PreRegisterCommandsEvent): Promise<void>;
-    /**
-     * Called before guild commands registration. This method can cancel the registration of the command and handle it manually.
-     * This method is called after guilds of the command are resolved. It is called after `onBeforePrepareGuildCommandsRegistration` if that stage was not handled.
-     * @param ctx The context
-     * @param event The command registration data
-     */
-    onBeforeRegisterGuildCommands(ctx: CommandKitPluginRuntime, event: PreRegisterCommandsEvent): Promise<void>;
-    /**
-     * Called after command and all of its deferred functions are executed.
-     * @param ctx The context
-     * @param env The environment of the command. This environment contains the command execution data such as command context and more.
-     */
-    onAfterCommand(ctx: CommandKitPluginRuntime, env: CommandKitEnvironment): Promise<void>;
-    /**
-     * Called before emitting an event
-     * @param ctx The context
-     * @param event The event that is being emitted
-     */
-    willEmitEvent(ctx: CommandKitPluginRuntime, event: CommandKitEventDispatch): Promise<void>;
-}
-declare function isRuntimePlugin(plugin: unknown): plugin is RuntimePlugin;
-
-type CommandKitPlugin = RuntimePlugin | CompilerPlugin;
-type MaybeFalsey<T> = T | false | null | undefined;
-interface CommandKitEventDispatch {
-    name: string;
-    args: unknown[];
-    namespace: string | null;
-    once: boolean;
-    metadata: ParsedEvent;
-    accept(): void;
-}
-
-interface PluginTransformParameters {
-    args: OnLoadArgs;
-    path: string;
-    contents: string | Uint8Array;
-    loader?: Loader;
-}
-interface TransformedResult {
-    contents?: string | Uint8Array;
-    loader?: Loader;
-}
-interface ResolveResult {
-    path?: string;
-    external?: boolean;
-}
-declare abstract class CompilerPlugin<T extends PluginOptions = PluginOptions> extends PluginCommon<T, CompilerPluginRuntime> {
-    readonly type = PluginType.Compiler;
-    /**
-     * Called when transformation is requested to this plugin
-     * @param params The parameters for the transformation
-     * @returns The transformed result
-     */
-    transform(params: PluginTransformParameters): Promise<MaybeFalsey<TransformedResult>>;
-    /**
-     * Called when a resolve is requested to this plugin
-     * @param args The arguments for the resolve
-     * @returns The resolved result
-     */
-    resolve(args: OnResolveArgs): Promise<MaybeFalsey<ResolveResult>>;
-    /**
-     * Called when a build is started
-     */
-    onBuildStart(): Promise<void>;
-    /**
-     * Called when a build is ended
-     */
-    onBuildEnd(): Promise<void>;
-}
-declare function isCompilerPlugin(plugin: unknown): plugin is CompilerPlugin;
-
-declare class CompilerPluginRuntime {
-    private readonly plugins;
-    readonly name = "CompilerPluginRuntime";
-    constructor(plugins: CompilerPlugin[]);
-    getPlugins(): CompilerPlugin<PluginOptions>[];
-    isEmpty(): boolean;
-    private onLoad;
-    private onResolve;
-    private onStart;
-    private onEnd;
-    private onDispose;
-    private onInit;
-    cleanup(): Promise<void>;
-    setup(build: Setup): Promise<void>;
-    toEsbuildPlugin(): {
-        name: string;
-        setup: (build: Setup) => Promise<void>;
-    };
-}
-declare function fromEsbuildPlugin(plugin: any): typeof CompilerPlugin;
-
-type CommonPluginRuntime = CommandKitPluginRuntime | CompilerPluginRuntime;
-
-type PluginOptions = Record<string, any>;
-declare enum PluginType {
-    Compiler = "compiler",
-    Runtime = "runtime"
-}
-declare abstract class PluginCommon<T extends PluginOptions = PluginOptions, C extends CommonPluginRuntime = CommonPluginRuntime> {
-    protected readonly options: T;
-    abstract readonly type: PluginType;
-    readonly id: `${string}-${string}-${string}-${string}-${string}`;
-    readonly loadedAt: number;
-    abstract readonly name: string;
-    constructor(options: T);
-    /**
-     * Called when this plugin is activated
-     */
-    activate(ctx: C): Promise<void>;
-    /**
-     * Called when this plugin is deactivated
-     */
-    deactivate(ctx: C): Promise<void>;
-}
-declare function isPlugin(plugin: unknown): plugin is PluginCommon<PluginOptions>;
-
-declare class CommandKitPluginRuntime {
-    readonly commandkit: CommandKit;
-    private plugins;
-    constructor(commandkit: CommandKit);
-    getPlugins(): Collection<string, RuntimePlugin<PluginOptions>>;
-    getPlugin(pluginName: string): RuntimePlugin | null;
-    softRegisterPlugin(plugin: RuntimePlugin): Promise<void>;
-    registerPlugin(plugin: RuntimePlugin): Promise<void>;
-    unregisterPlugin(plugin: RuntimePlugin): Promise<void>;
-    unregisterAllPlugins(): Promise<void>;
-    capture(): void;
-    execute<R = any>(f: AsyncFunction<[CommandKitPluginRuntime, RuntimePlugin], R | undefined>): Promise<true | R | undefined>;
-}
-
-type MaybePromise<T> = T | Promise<T>;
-type IdentifyFunction<R> = (context: EvaluationContext) => MaybePromise<R>;
-type DecideFunction<E, R> = (data: {
-    entities: E;
-}) => MaybePromise<R>;
-interface FeatureFlagDefinition<R, Entity> {
-    key: string;
-    description?: string;
-    identify?: IdentifyFunction<Entity>;
-    decide: DecideFunction<Entity, R>;
-}
-interface CommandFlagContext {
-    client: Client<true>;
-    commandkit: CommandKit;
-    command: {
-        interaction?: ChatInputCommandInteraction | AutocompleteInteraction | ContextMenuCommandInteraction;
-        message?: Message;
-        guild: Guild | null;
-        channel: TextBasedChannel | null;
-        command: LoadedCommand;
-    };
-    event: null;
-}
-interface EventFlagContext {
-    client: Client<true>;
-    commandkit: CommandKit;
-    event: {
-        data: ParsedEvent;
-        event: string;
-        namespace: string | null;
-        arguments: any[];
-        argumentsAs<E extends keyof ClientEvents>(event: E): ClientEvents[E];
-    };
-    command: null;
-}
-type EvaluationContext = CommandFlagContext | EventFlagContext;
-type CustomEvaluationFunction<E> = () => MaybePromise<E>;
-type CustomEvaluationContext<E> = {
-    identify: E | CustomEvaluationFunction<E>;
-};
-interface FlagRunner<E, R> {
-    (): Promise<R>;
-    run(context: CustomEvaluationContext<E>): Promise<R>;
-}
-declare class FeatureFlag<R, T> {
-    readonly options: FeatureFlagDefinition<R, T>;
-    constructor(options: FeatureFlagDefinition<R, T>);
-    private getContext;
-    execute(res?: T): Promise<R>;
-}
-declare function flag<Returns = boolean, Entity = Record<any, any>>(options: FeatureFlagDefinition<Returns, Entity>): FlagRunner<Entity, Returns>;
-
-declare class FlagStore extends Collection<string, FeatureFlag<any, any>> {
-}
-
-interface CommandKitConfiguration {
-    defaultLocale: Locale;
-    getMessageCommandPrefix: (message: Message) => Awaitable<string | string[]>;
-}
-declare let commandkit: CommandKit;
-type BootstrapFunction = GenericFunction<[CommandKit]> | AsyncFunction<[CommandKit]>;
-/**
- * Registers a bootstrap hook that will be called when the CommandKit instance is created.
- * This is useful for plugins that need to run some code after the CommandKit instance is fully initialized.
- * Note that not all commandkit dependiencs are available at this point. It is recommended to use the `onApplicationBootstrap` hook instead,
- * if you need access to the commandkit dependencies.
- * @param fn The bootstrap function to register.
- * @example ```ts
- * import { onBootstrap } from 'commandkit';
- *
- * onBootstrap(async (commandkit) => {
- *   // Do something with the commandkit instance
- * })
- * ```
- */
-declare function onBootstrap<F extends BootstrapFunction>(fn: F): void;
-/**
- * Registers a bootstrap hook that will be called when the CommandKit instance is created.
- * This is useful for plugins that need to run some code after the CommandKit instance is fully initialized.
- * @param fn The bootstrap function to register.
- * @example ```ts
- * import { onApplicationBootstrap } from 'commandkit';
- *
- * onApplicationBootstrap(async (commandkit) => {
- *   // Do something with the commandkit instance
- * })
- * ```
- */
-declare function onApplicationBootstrap<F extends BootstrapFunction>(fn: F): void;
-declare class CommandKit extends EventEmitter {
-    #private;
-    private readonly options;
-    eventInterceptor: EventInterceptor;
-    static readonly createElement: typeof createElement;
-    static readonly Fragment: typeof Fragment;
-    readonly config: CommandKitConfiguration;
-    readonly store: Map<string, any>;
-    readonly flags: FlagStore;
-    commandsRouter: CommandsRouter;
-    eventsRouter: EventsRouter;
-    readonly commandHandler: AppCommandHandler;
-    readonly eventHandler: AppEventsHandler;
-    readonly plugins: CommandKitPluginRuntime;
-    readonly events: CommandKitEventsChannel;
-    static instance: CommandKit | undefined;
-    /**
-     * Create a new command and event handler with CommandKit.
-     *
-     * @param options - The default CommandKit configuration.
-     * @see {@link https://commandkit.js.org/docs/guide/commandkit-setup}
-     */
-    constructor(options: CommandKitOptions);
-    /**
-     * Starts the commandkit application.
-     * @param token The application token to connect to the discord gateway. If not provided, it will use the `TOKEN` or `DISCORD_TOKEN` environment variable. If set to `false`, it will not login.
-     */
-    start(token?: string | false): Promise<void>;
-    /**
-     * Loads all the plugins.
-     */
-    loadPlugins(): Promise<void>;
-    /**
-     * Whether or not the commandkit application has started.
-     */
-    get started(): boolean;
-    /**
-     * Sets the prefix resolver for the command handler.
-     * @param resolver The resolver function.
-     */
-    setPrefixResolver(resolver: (message: Message) => Awaitable<string | string[]>): this;
-    /**
-     * Sets the default locale for the command handler.
-     * @param locale The default locale.
-     */
-    setDefaultLocale(locale: Locale): this;
-    /**
-     * Get the client attached to this CommandKit instance.
-     */
-    get client(): discord_js.Client<boolean>;
-    /**
-     * Updates application commands with the latest from "commandsPath".
-     */
-    reloadCommands(): Promise<void>;
-    /**
-     * Updates application events with the latest from "eventsPath".
-     */
-    reloadEvents(): Promise<void>;
-    /**
-     * Increment the client listeners count.
-     */
-    incrementClientListenersCount(): void;
-    /**
-     * Decrement the client listeners count.
-     */
-    decrementClientListenersCount(): void;
-    /**
-     * Path to the app directory. Returns `null` if not found.
-     * The lookup order is:
-     * - `./app`
-     * - `./src/app`
-     */
-    getAppDirectory(): string | null;
-    getPath(to: 'commands' | 'events'): string | null;
-}
-
-export { cancelAfter as $, AppCommandHandler as A, type CommandKitConfiguration as B, type CommandTypeData as C, commandkit as D, type BootstrapFunction as E, onBootstrap as F, onApplicationBootstrap as G, type GenericFunction as H, type InteractionCommandContext as I, isCommandWorkerContext as J, type AsyncFunction as K, type LoadedCommand as L, type MessageCommandContext as M, exitContext as N, provideContext as O, type PreparedAppCommandExecution as P, makeContextAwareFunction as Q, type RunCommand as R, type SlashCommandMiddlewareContext as S, getCommandKit as T, type UserContextMenuCommandContext as U, getContext as V, useEnvironment as W, type CommandKitEnvironmentInternalData as X, CommandKitEnvironment as Y, CommandKitEnvironmentType as Z, after as _, type ResolvableCommand as a, type CommandKitOptions as a0, type CommandContext as a1, type CommandData as a2, type PluginTransformParameters as a3, type TransformedResult as a4, type ResolveResult as a5, CompilerPlugin as a6, isCompilerPlugin as a7, RuntimePlugin as a8, isRuntimePlugin as a9, registerDevHooks as aA, type PluginOptions as aB, PluginType as aC, PluginCommon as aD, isPlugin as aE, FlagStore as aF, type CommandKitPlugin as aa, type MaybeFalsey as ab, type CommandKitEventDispatch as ac, CommandKitPluginRuntime as ad, CompilerPluginRuntime as ae, fromEsbuildPlugin as af, type CommonPluginRuntime as ag, type MaybePromise as ah, type IdentifyFunction as ai, type DecideFunction as aj, type FeatureFlagDefinition as ak, type CommandFlagContext as al, type EventFlagContext as am, type EvaluationContext as an, type CustomEvaluationFunction as ao, type CustomEvaluationContext as ap, type FlagRunner as aq, FeatureFlag as ar, flag as as, AppCommandRunner as at, type ListenerFunction as au, CommandKitEventsChannel as av, type EventListener as aw, type LoadedEvent as ax, type AppEventsHandlerLoadedData as ay, AppEventsHandler as az, type CommandBuilderLike as b, CommandExecutionMode as c, type ContextParameters as d, type MessageCommandMiddlewareContext as e, type InteractionCommandMiddlewareContext as f, type ChatInputCommandContext as g, type AutocompleteCommandContext as h, type AutocompleteCommandMiddlewareContext as i, type MessageContextMenuCommandContext as j, type MessageContextMenuCommandMiddlewareContext as k, type UserContextMenuCommandMiddlewareContext as l, type CommandContextOptions as m, type AnyCommandExecute as n, type ChatInputCommand as o, type AutocompleteCommand as p, type MessageContextMenuCommand as q, type UserContextMenuCommand as r, type MessageCommand as s, type MiddlewareContextArgs as t, Context as u, MiddlewareContext as v, type PreRegisterCommandsEvent as w, CommandRegistrar as x, CommandKit as y, type CommandKitHMREvent as z };