commandkit 1.0.0-dev.20250529020123 → 1.0.0-dev.20250530015910

package/dist/CommandKit-CDlCsGCx.d.ts

@@ -0,0 +1,926 @@
+import { EventInterceptor } from "./EventInterceptor-D_oEWSnF.js";
+import { Fragment, createElement } from "./element-D_nyVwgB.js";
+import { MessageCommandOptions, MessageCommandParser } from "./MessageCommandParser-tzroBwij.js";
+import { Command, CommandsRouter, Middleware } from "./CommandsRouter-C7X-eXE2.js";
+import { EventsRouter, ParsedEvent } from "./EventsRouter-BacqK6z3.js";
+import { HMREventType } from "./constants-Ce6w4OFe.js";
+import * as discord_js0 from "discord.js";
+import { AutocompleteInteraction, Awaitable, CacheType, ChatInputCommandInteraction, Client, ClientEvents, Collection, ContextMenuCommandBuilder, ContextMenuCommandInteraction, Guild, Interaction, Locale, Message, MessageContextMenuCommandInteraction, RESTPostAPIApplicationCommandsJSONBody, SlashCommandBuilder, TextBasedChannel, UserContextMenuCommandInteraction } from "discord.js";
+import EventEmitter from "node:events";
+import { DirectiveTransformerOptions } from "directive-to-hof";
+
+//#region src/types.d.ts
+/**
+ * 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[];
+};
+//#endregion
+//#region src/context/async-context.d.ts
+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;
+//#endregion
+//#region src/app/register/CommandRegistrar.d.ts
+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>;
+}
+//#endregion
+//#region src/context/environment.d.ts
+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;
+//#endregion
+//#region src/app/commands/Context.d.ts
+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;
+}
+//#endregion
+//#region src/app/commands/AppCommandRunner.d.ts
+declare class AppCommandRunner {
+  #private;
+  private handler;
+  constructor(handler: AppCommandHandler);
+  runCommand(prepared: PreparedAppCommandExecution, source: Interaction | Message): Promise<void>;
+  getExecutionMode(source: Interaction | Message): CommandExecutionMode;
+}
+//#endregion
+//#region src/app/handlers/AppCommandHandler.d.ts
+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;
+}
+//#endregion
+//#region src/events/CommandKitEventsChannel.d.ts
+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;
+}
+//#endregion
+//#region src/app/handlers/AppEventsHandler.d.ts
+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;
+}
+//#endregion
+//#region src/utils/dev-hooks.d.ts
+interface CommandKitHMREvent {
+  event: HMREventType;
+  path: string;
+  accept: () => void;
+  preventDefault: () => void;
+}
+declare function registerDevHooks(commandkit: CommandKit): void;
+//#endregion
+//#region src/plugins/RuntimePlugin.d.ts
+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;
+//#endregion
+//#region src/plugins/types.d.ts
+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;
+}
+//#endregion
+//#region src/plugins/CompilerPlugin.d.ts
+interface PluginTransformParameters {
+  code: string;
+  id: string;
+}
+interface TransformedResult {
+  code?: string;
+  map?: string | null;
+}
+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>>;
+}
+declare function isCompilerPlugin(plugin: unknown): plugin is CompilerPlugin;
+//#endregion
+//#region src/plugins/plugin-runtime/builtin/CommonDirectiveTransformer.d.ts
+type CommonDirectiveTransformerOptions = DirectiveTransformerOptions & {
+  enabled?: boolean;
+};
+declare abstract class CommonDirectiveTransformer extends CompilerPlugin<CommonDirectiveTransformerOptions> {
+  private transformer;
+  activate(ctx: CompilerPluginRuntime): Promise<void>;
+  deactivate(ctx: CompilerPluginRuntime): Promise<void>;
+  transform(params: PluginTransformParameters): Promise<MaybeFalsey<TransformedResult>>;
+}
+//#endregion
+//#region src/plugins/plugin-runtime/CompilerPluginRuntime.d.ts
+declare class CompilerPluginRuntime {
+  private readonly plugins;
+  readonly name = "CompilerPluginRuntime";
+  private initialized;
+  constructor(plugins: CompilerPlugin[]);
+  getPlugins(): CompilerPlugin<PluginOptions>[];
+  isEmpty(): boolean;
+  transform(code: string, id: string): Promise<{
+    code: string;
+    map: string | null;
+  }>;
+  init(): Promise<void>;
+  destroy(): Promise<void>;
+  toJSON(): {
+    name: string;
+    transform: (code: string, id: string) => Promise<{
+      code: string;
+      map: string | null;
+    }>;
+  };
+}
+//#endregion
+//#region src/plugins/plugin-runtime/runtime.d.ts
+type CommonPluginRuntime = CommandKitPluginRuntime | CompilerPluginRuntime;
+//#endregion
+//#region src/plugins/PluginCommon.d.ts
+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>;
+//#endregion
+//#region src/plugins/plugin-runtime/CommandKitPluginRuntime.d.ts
+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>;
+}
+//#endregion
+//#region src/flags/feature-flags.d.ts
+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>;
+//#endregion
+//#region src/flags/store.d.ts
+declare class FlagStore extends Collection<string, FeatureFlag<any, any>> {}
+//#endregion
+//#region src/CommandKit.d.ts
+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 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;
+  commandHandler: AppCommandHandler;
+  eventHandler: AppEventsHandler;
+  plugins: CommandKitPluginRuntime;
+  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_js0.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;
+}
+//#endregion
+export { AnyCommandExecute, AppCommandHandler, AppCommandRunner, AppEventsHandler, AppEventsHandlerLoadedData, AsyncFunction, AutocompleteCommand, AutocompleteCommandContext, AutocompleteCommandMiddlewareContext, BootstrapFunction, ChatInputCommand, ChatInputCommandContext, CommandBuilderLike, CommandContext, CommandContextOptions, CommandData, CommandExecutionMode, CommandFlagContext, CommandKit, CommandKitConfiguration, CommandKitEnvironment, CommandKitEnvironmentInternalData, CommandKitEnvironmentType, CommandKitEventDispatch, CommandKitEventsChannel, CommandKitHMREvent, CommandKitOptions, CommandKitPlugin, CommandKitPluginRuntime, CommandRegistrar, CommandTypeData, CommonDirectiveTransformer, CommonDirectiveTransformerOptions, CommonPluginRuntime, CompilerPlugin, CompilerPluginRuntime, Context, ContextParameters, CustomEvaluationContext, CustomEvaluationFunction, DecideFunction, EvaluationContext, EventFlagContext, EventListener, FeatureFlag, FeatureFlagDefinition, FlagRunner, FlagStore, GenericFunction, IdentifyFunction, InteractionCommandContext, InteractionCommandMiddlewareContext, ListenerFunction, LoadedCommand, LoadedEvent, MaybeFalsey, MaybePromise, MessageCommand, MessageCommandContext, MessageCommandMiddlewareContext, MessageContextMenuCommand, MessageContextMenuCommandContext, MessageContextMenuCommandMiddlewareContext, MiddlewareContext, MiddlewareContextArgs, PluginCommon, PluginOptions, PluginTransformParameters, PluginType, PreRegisterCommandsEvent, PreparedAppCommandExecution, ResolvableCommand, RunCommand, RuntimePlugin, SlashCommandMiddlewareContext, TransformedResult, UserContextMenuCommand, UserContextMenuCommandContext, UserContextMenuCommandMiddlewareContext, after, cancelAfter, commandkit, exitContext, flag, getCommandKit, getContext, isCommandWorkerContext, isCompilerPlugin, isPlugin, isRuntimePlugin, makeContextAwareFunction, onApplicationBootstrap, onBootstrap, provideContext, registerDevHooks, useEnvironment };
+//# sourceMappingURL=CommandKit-CDlCsGCx.d.ts.map