commandkit 1.0.0-dev.20250611020404 → 1.0.0-dev.20250611125312

package/dist/{CommandKit-B-mjdP5x.d.ts → CommandKit-BkMUDbou.d.ts}

@@ -1,9 +1,9 @@
-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 { EventInterceptor } from "./EventInterceptor-x-R2qshQ.js";
+import { Fragment, createElement } from "./element-CAXu1XtK.js";
+import { MessageCommandOptions, MessageCommandParser } from "./MessageCommandParser-ROLibZPX.js";
+import { Command, CommandsRouter, Middleware } from "./CommandsRouter-CoOA7hkf.js";
 import { EventsRouter, ParsedEvent } from "./EventsRouter-BacqK6z3.js";
-import { HMREventType } from "./constants-BPWSrMkn.js";
+import { HMREventType } from "./constants-BTttfrm3.js";
 import EventEmitter from "node:events";
 import { AutocompleteInteraction, Awaitable, CacheType, ChatInputCommandInteraction, Client, ClientEvents, Collection, ContextMenuCommandBuilder, ContextMenuCommandInteraction, Guild, Interaction, Locale, Message, MessageContextMenuCommandInteraction, RESTPostAPIApplicationCommandsJSONBody, SlashCommandBuilder, TextBasedChannel, UserContextMenuCommandInteraction } from "discord.js";
 import { DirectiveTransformerOptions } from "directive-to-hof";
@@ -35,12 +35,23 @@ interface CommandContext<T extends Interaction, Cached extends CacheType> {
    */
   handler: CommandKit;
 }
+/**
+ * Represents a command that can be executed by CommandKit.
+ */
 type CommandData = RESTPostAPIApplicationCommandsJSONBody & {
   guilds?: string[];
 };
 //#endregion
 //#region src/context/async-context.d.ts
+/**
+ * Represents a generic function type that can accept any number of arguments.
+ */
 type GenericFunction<A extends any[] = any[]> = (...args: A) => any;
+/**
+ * Checks if the given worker is a CommandKit worker context.
+ * @param worker The worker to check.
+ * @returns True if the worker is a CommandKit worker context, false otherwise.
+ */
 declare function isCommandWorkerContext(worker: any): worker is CommandKitEnvironment;
 /**
  * Represents an async function that can be cached
@@ -49,6 +60,12 @@ declare function isCommandWorkerContext(worker: any): worker is CommandKitEnviro
  */
 type AsyncFunction<R extends any[] = any[], T = any> = (...args: R) => Promise<T>;
 declare function exitContext<T>(fn: () => T): T;
+/**
+ * Executes the provided function within a CommandKit context.
+ * @param value The CommandKit environment to use for the context.
+ * @param receiver The function to execute within the context.
+ * @returns The result of the receiver function.
+ */
 declare function provideContext<R>(value: CommandKitEnvironment, receiver: () => R): R;
 /**
  * Returns a context-aware version of the given function.
@@ -77,12 +94,22 @@ declare function getContext(): CommandKitEnvironment | undefined;
 declare function useEnvironment(): CommandKitEnvironment;
 //#endregion
 //#region src/app/register/CommandRegistrar.d.ts
+/**
+ * Event object passed to plugins before command registration.
+ */
 interface PreRegisterCommandsEvent {
   preventDefault(): void;
   commands: CommandData[];
 }
+/**
+ * Handles registration of Discord application commands (slash commands, context menus).
+ */
 declare class CommandRegistrar {
   readonly commandkit: CommandKit;
+  /**
+   * @private
+   * @internal
+   */
   private api;
   /**
    * Creates an instance of CommandRegistrar.
@@ -108,16 +135,52 @@ declare class CommandRegistrar {
 }
 //#endregion
 //#region src/context/environment.d.ts
+/**
+ * Represents the internal data structure for the CommandKit environment.
+ */
 interface CommandKitEnvironmentInternalData {
+  /**
+   * The error that occurred during command execution, if any.
+   * This is set when an error occurs during the execution of a command.
+   */
   executionError: Error | null;
+  /**
+   * The type of the environment, which can be used to differentiate between
+   * different execution contexts (e.g., command handler, event handler, etc.).
+   */
   type: CommandKitEnvironmentType | null;
+  /**
+   * A map of variables that can be used to store and retrieve data during command execution.
+   * This allows for sharing data between different parts of the command execution process.
+   */
   variables: Map<string, any>;
+  /**
+   * A map of deferred functions that will be executed after the command has finished executing.
+   * This is useful for running cleanup tasks or additional processing after the main command logic.
+   */
   deferredFunctions: Map<string, GenericFunction<[CommandKitEnvironment]>>;
+  /**
+   * A marker string that can be used to identify the command execution.
+   * This is useful for logging and debugging purposes.
+   */
   marker: string;
+  /**
+   * The start time of the command execution.
+   */
   markStart: number;
+  /**
+   * The end time of the command execution.
+   */
   markEnd: number;
+  /**
+   * The context associated with the command execution.
+   * This can be used to access request-specific data or application state.
+   */
   context: Context | null;
 }
+/**
+ * Represents the execution environment for CommandKit commands.
+ */
 declare class CommandKitEnvironment {
   #private;
   readonly commandkit: CommandKit;
@@ -210,18 +273,41 @@ declare enum CommandKitEnvironmentType {
   CommandHandler = "COMMAND_HANDLER",
 }
 /**
- * Runs the given function after the current command has finished executing.
+ * Schedules the given function to run 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.
+ * @example import { after } from 'commandkit';
+ *
+ * // inside a command
+ * export const chatInput: ChatInputCommand = async (ctx) => {
+ *   after(() => {
+ *     console.log('This will run after the command has finished executing.');
+ *   });
+ *
+ *   // ... command logic
+ * }
  */
 declare function after(fn: GenericFunction<[CommandKitEnvironment]>): string;
 /**
  * Cancels a deferred function registered with `after`.
  * @param id The deferred function id to cancel.
+ * @example import { cancelAfter } from 'commandkit';
+ * // inside a command
+ * export const chatInput: ChatInputCommand = async (ctx) => {
+ *   const id = after(() => {
+ *     console.log('This will run after the command has finished executing.');
+ *   });
+ *
+ *  // cancel the deferred function if needed
+ *  if (something) cancelAfter(id);
+ * }
  */
 declare function cancelAfter(id: string): void;
 //#endregion
 //#region src/app/commands/Context.d.ts
+/**
+ * Enumeration of different command execution modes supported by CommandKit.
+ */
 declare const CommandExecutionMode: {
   readonly ChatInputCommand: "chatInput";
   readonly MessageContextMenu: "messageContextMenu";
@@ -229,7 +315,13 @@ declare const CommandExecutionMode: {
   readonly Autocomplete: "autocomplete";
   readonly Message: "message";
 };
+/**
+ * Type representing the possible command execution modes.
+ */
 type CommandExecutionMode = (typeof CommandExecutionMode)[keyof typeof CommandExecutionMode];
+/**
+ * Parameters required to create a command context.
+ */
 interface ContextParameters<T extends CommandExecutionMode, Args = Record<string, any>> {
   command: LoadedCommand;
   environment?: CommandKitEnvironment;
@@ -241,28 +333,92 @@ interface ContextParameters<T extends CommandExecutionMode, Args = Record<string
   store?: Map<string, any>;
   customArgs?: Args;
 }
+/**
+ * Context for message-based commands.
+ */
 type MessageCommandContext = Context<'message'>;
+/**
+ * Context for interaction-based commands.
+ */
 type InteractionCommandContext = Context<'autocomplete' | 'chatInput' | 'messageContextMenu' | 'userContextMenu'>;
+/**
+ * Middleware context for message-based commands.
+ */
 type MessageCommandMiddlewareContext = MiddlewareContext<'message'>;
+/**
+ * Middleware context for interaction-based commands.
+ */
 type InteractionCommandMiddlewareContext = MiddlewareContext<'autocomplete' | 'chatInput' | 'messageContextMenu' | 'userContextMenu'>;
+/**
+ * Context for chat input (slash) commands.
+ */
 type ChatInputCommandContext = Context<'chatInput'>;
+/**
+ * Middleware context for slash commands.
+ */
 type SlashCommandMiddlewareContext = MiddlewareContext<'chatInput'>;
+/**
+ * Context for autocomplete interactions.
+ */
 type AutocompleteCommandContext = Context<'autocomplete'>;
+/**
+ * Middleware context for autocomplete interactions.
+ */
 type AutocompleteCommandMiddlewareContext = MiddlewareContext<'autocomplete'>;
+/**
+ * Context for message context menu commands.
+ */
 type MessageContextMenuCommandContext = Context<'messageContextMenu'>;
+/**
+ * Middleware context for message context menu commands.
+ */
 type MessageContextMenuCommandMiddlewareContext = MiddlewareContext<'messageContextMenu'>;
+/**
+ * Context for user context menu commands.
+ */
 type UserContextMenuCommandContext = Context<'userContextMenu'>;
+/**
+ * Middleware context for user context menu commands.
+ */
 type UserContextMenuCommandMiddlewareContext = MiddlewareContext<'userContextMenu'>;
+/**
+ * Type representing command context options based on execution mode.
+ */
 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;
+/**
+ * Generic type for command execution functions.
+ */
 type AnyCommandExecute<ContextType extends Context = Context> = (ctx: ContextType) => Awaitable<unknown>;
+/**
+ * Type for chat input command execution functions.
+ */
 type ChatInputCommand = AnyCommandExecute<ChatInputCommandContext>;
+/**
+ * Type for autocomplete command execution functions.
+ */
 type AutocompleteCommand = AnyCommandExecute<AutocompleteCommandContext>;
+/**
+ * Type for message context menu command execution functions.
+ */
 type MessageContextMenuCommand = AnyCommandExecute<MessageContextMenuCommandContext>;
+/**
+ * Type for user context menu command execution functions.
+ */
 type UserContextMenuCommand = AnyCommandExecute<UserContextMenuCommandContext>;
+/**
+ * Type for message command execution functions.
+ */
 type MessageCommand = AnyCommandExecute<MessageCommandContext>;
+/**
+ * Arguments for middleware context.
+ */
 interface MiddlewareContextArgs {
   setCommandRunner?: GenericFunction<[RunCommand]>;
 }
+/**
+ * Represents the execution context for a command, providing access to Discord.js objects,
+ * command metadata, and various utility methods for command execution.
+ */
 declare class Context<ExecutionMode extends CommandExecutionMode = CommandExecutionMode, Args extends Record<string, any> = Record<string, any>> {
   #private;
   readonly commandkit: CommandKit;
@@ -299,6 +455,10 @@ declare class Context<ExecutionMode extends CommandExecutionMode = CommandExecut
    * The command that this context belongs to.
    */
   readonly command: LoadedCommand;
+  /**
+   * @private
+   * @internal
+   */
   private _locale;
   /**
    * Creates a new command context.
@@ -311,7 +471,13 @@ declare class Context<ExecutionMode extends CommandExecutionMode = CommandExecut
    * This store is shared across all contexts in the same command execution, including the cloned contexts and middleware contexts.
    */
   get store(): Map<string, any>;
+  /**
+   * Gets the name of the current command.
+   */
   get commandName(): string;
+  /**
+   * Gets the command options based on the execution mode.
+   */
   get options(): CommandContextOptions<ExecutionMode>;
   /**
    * Whether this context was forwarded from another context. This happens when a command forwards its context to another command.
@@ -375,9 +541,17 @@ declare class Context<ExecutionMode extends CommandExecutionMode = CommandExecut
   setLocale(locale: Locale | null): void;
   /**
    * Creates a clone of this context
+   * @param config - Optional partial config to override in the clone
    */
   clone(config?: Partial<ContextParameters<ExecutionMode>>): Context<ExecutionMode>;
+  /**
+   * Checks if this context is a middleware context.
+   */
   isMiddleware(): this is MiddlewareContext<ExecutionMode>;
+  /**
+   * Gets the command arguments (only available for message commands).
+   * @returns Array of command arguments
+   */
   args(): string[];
   /**
    * Stops upcoming middleware or current command execution.
@@ -387,6 +561,9 @@ declare class Context<ExecutionMode extends CommandExecutionMode = CommandExecut
    */
   exit(): never;
 }
+/**
+ * Extended context class for middleware execution with additional control methods.
+ */
 declare class MiddlewareContext<T extends CommandExecutionMode = CommandExecutionMode> extends Context<T, MiddlewareContextArgs> {
   #private;
   /**
@@ -410,16 +587,42 @@ declare class MiddlewareContext<T extends CommandExecutionMode = CommandExecutio
 }
 //#endregion
 //#region src/app/commands/AppCommandRunner.d.ts
+/**
+ * Handles the execution of application commands for CommandKit.
+ * Manages middleware execution, environment setup, and command invocation.
+ */
 declare class AppCommandRunner {
   #private;
   private handler;
+  /**
+   * Creates a new AppCommandRunner instance.
+   * @param handler - The app command handler instance to use for command execution
+   */
   constructor(handler: AppCommandHandler);
+  /**
+   * Executes a prepared command with middleware support and environment setup.
+   * Handles the complete command lifecycle including before/after middleware execution.
+   * @param prepared - The prepared command execution data
+   * @param source - The source interaction or message that triggered the command
+   */
   runCommand(prepared: PreparedAppCommandExecution, source: Interaction | Message): Promise<void>;
+  /**
+   * Determines the execution mode based on the source of the command.
+   * @param source - The interaction or message that triggered the command
+   * @returns The appropriate command execution mode
+   */
   getExecutionMode(source: Interaction | Message): CommandExecutionMode;
 }
 //#endregion
 //#region src/app/handlers/AppCommandHandler.d.ts
+/**
+ * Function type for wrapping command execution with custom logic.
+ */
 type RunCommand = <T extends AsyncFunction>(fn: T) => T;
+/**
+ * @private
+ * @internal
+ */
 interface AppCommandNative {
   command: SlashCommandBuilder | Record<string, any>;
   chatInput?: (ctx: Context) => Awaitable<unknown>;
@@ -428,61 +631,198 @@ interface AppCommandNative {
   messageContextMenu?: (ctx: Context) => Awaitable<unknown>;
   userContextMenu?: (ctx: Context) => Awaitable<unknown>;
 }
+/**
+ * @private
+ * @internal
+ */
 type AppCommand = AppCommandNative & Record<string, any>;
+/**
+ * @private
+ * @internal
+ */
 interface AppCommandMiddleware {
   beforeExecute: (ctx: Context) => Awaitable<unknown>;
   afterExecute: (ctx: Context) => Awaitable<unknown>;
 }
+/**
+ * Represents a loaded command with its metadata and configuration.
+ */
 interface LoadedCommand {
   command: Command;
   data: AppCommand;
   guilds?: string[];
 }
+/**
+ * Type representing command data identifier.
+ */
 type CommandTypeData = string;
+/**
+ * Type for commands that can be resolved by the handler.
+ */
 type ResolvableCommand = CommandTypeData | (string & {});
+/**
+ * @private
+ * @internal
+ */
 interface LoadedMiddleware {
   middleware: Middleware;
   data: AppCommandMiddleware;
 }
+/**
+ * Represents a prepared command execution with all necessary data and middleware.
+ */
 interface PreparedAppCommandExecution {
   command: LoadedCommand;
   middlewares: LoadedMiddleware[];
   messageCommandParser?: MessageCommandParser;
 }
+/**
+ * Type representing command builder objects supported by CommandKit.
+ */
 type CommandBuilderLike = SlashCommandBuilder | ContextMenuCommandBuilder | Record<string, any>;
+/**
+ * Handles application commands for CommandKit, including loading, registration, and execution.
+ * Manages both slash commands and message commands with middleware support.
+ */
 declare class AppCommandHandler {
   readonly commandkit: CommandKit;
+  /**
+   * @private
+   * @internal
+   */
   private loadedCommands;
+  /**
+   * @private
+   * @internal
+   */
   private loadedMiddlewares;
+  /**
+   * @private
+   * @internal
+   */
   private commandNameToId;
+  /**
+   * @private
+   * @internal
+   */
   private subcommandPathToId;
+  /**
+   * Command registrar for handling Discord API registration.
+   */
   readonly registrar: CommandRegistrar;
+  /**
+   * @private
+   * @internal
+   */
   private onInteraction;
+  /**
+   * @private
+   * @internal
+   */
   private onMessageCreate;
+  /**
+   * Command runner instance for executing commands.
+   */
   readonly commandRunner: AppCommandRunner;
+  /**
+   * External command data storage.
+   */
   readonly externalCommandData: Collection<string, Command>;
+  /**
+   * External middleware data storage.
+   */
   readonly externalMiddlewareData: Collection<string, Middleware>;
+  /**
+   * Creates a new AppCommandHandler instance.
+   * @param commandkit - The CommandKit instance
+   */
   constructor(commandkit: CommandKit);
+  /**
+   * Prints a formatted banner showing all loaded commands organized by category.
+   */
   printBanner(): void;
+  /**
+   * Gets an array of all loaded commands.
+   * @returns Array of loaded commands
+   */
   getCommandsArray(): LoadedCommand[];
+  /**
+   * Registers event handlers for Discord interactions and messages.
+   */
   registerCommandHandler(): void;
+  /**
+   * Prepares a command for execution by resolving the command and its middleware.
+   * @param source - The interaction or message that triggered the command
+   * @param cmdName - Optional command name override
+   * @returns Prepared command execution data or null if command not found
+   */
   prepareCommandRun(source: Interaction | Message, cmdName?: string): Promise<PreparedAppCommandExecution | null>;
+  /**
+   * Reloads all commands and middleware from scratch.
+   */
   reloadCommands(): Promise<void>;
+  /**
+   * Adds external middleware data to be loaded.
+   * @param data - Array of middleware data to add
+   */
   addExternalMiddleware(data: Middleware[]): Promise<void>;
+  /**
+   * Adds external command data to be loaded.
+   * @param data - Array of command data to add
+   */
   addExternalCommands(data: Command[]): Promise<void>;
+  /**
+   * Registers externally loaded middleware.
+   * @param data - Array of loaded middleware to register
+   */
   registerExternalLoadedMiddleware(data: LoadedMiddleware[]): Promise<void>;
+  /**
+   * Registers externally loaded commands.
+   * @param data - Array of loaded commands to register
+   */
   registerExternalLoadedCommands(data: LoadedCommand[]): Promise<void>;
+  /**
+   * Loads all commands and middleware from the router.
+   */
   loadCommands(): Promise<void>;
+  /**
+   * @private
+   * @internal
+   */
   private loadMiddleware;
+  /**
+   * @private
+   * @internal
+   */
   private loadCommand;
 }
 //#endregion
 //#region src/events/CommandKitEventsChannel.d.ts
+/**
+ * The function type for event listeners.
+ */
 type ListenerFunction = GenericFunction | AsyncFunction;
+/**
+ * Represents a channel for emitting and listening to events in CommandKit.
+ * This class provides methods to manage event listeners and emit events
+ * within a specific namespace.
+ */
 declare class CommandKitEventsChannel {
   readonly commandkit: CommandKit;
   private emitter;
+  /**
+   * Creates a new instance of CommandKitEventsChannel.
+   * @param commandkit The CommandKit instance that this channel belongs to.
+   */
   constructor(commandkit: CommandKit);
+  /**
+   * Creates a namespaced event channel. This allows you to manage events
+   * within a specific namespace, preventing conflicts with other event channels.
+   * This is useful for organizing events related to different parts of your application.
+   * @param namespace The namespace for the event channel.
+   * @returns An object containing methods for managing events within the namespace.
+   * @example commandkit.events.to('customNamespace').emit('eventName', data);
+   */
   to(namespace: string): {
     on: (event: string, listener: ListenerFunction) => void;
     off: (event: string, listener: ListenerFunction) => void;
@@ -490,19 +830,56 @@ declare class CommandKitEventsChannel {
     emit: (event: string, ...args: any[]) => boolean;
     removeAllListeners: (event: string) => void;
   };
+  /**
+   * Register an event listener for a specific event within the namespace.
+   * @param namespace The namespace for the event channel.
+   * @param event The name of the event to listen for.
+   * @param listener The function to call when the event is emitted.
+   */
   on(namespace: string, event: string, listener: ListenerFunction): void;
+  /**
+   * Unregister an event listener for a specific event within the namespace.
+   * @param namespace The namespace for the event channel.
+   * @param event The name of the event to stop listening for.
+   * @param listener The function that was registered as the listener.
+   */
   off(namespace: string, event: string, listener: ListenerFunction): void;
+  /**
+   * Register an event listener that will be called only once for a specific event
+   * within the namespace.
+   * @param namespace The namespace for the event channel.
+   * @param event The name of the event to listen for.
+   * @param listener The function to call when the event is emitted.
+   */
   once(namespace: string, event: string, listener: ListenerFunction): void;
+  /**
+   * Emit an event within the specified namespace, calling all registered listeners.
+   * @param namespace The namespace for the event channel.
+   * @param event The name of the event to emit.
+   * @param args The arguments to pass to the listeners.
+   * @returns A boolean indicating whether any listeners were called.
+   */
   emit(namespace: string, event: string, ...args: any[]): boolean;
+  /**
+   * Remove all listeners for a specific event or all events within the namespace.
+   * @param namespace The namespace for the event channel.
+   * @param event The name of the event to remove listeners for. If not provided, all listeners for all events in the namespace will be removed.
+   */
   removeAllListeners(namespace: string): void;
   removeAllListeners(namespace: string, event: string): void;
 }
 //#endregion
 //#region src/app/handlers/AppEventsHandler.d.ts
+/**
+ * Represents an event listener with its configuration.
+ */
 type EventListener = {
   handler: ListenerFunction;
   once: boolean;
 };
+/**
+ * Represents a loaded event with all its listeners.
+ */
 interface LoadedEvent {
   name: string;
   namespace: string | null;
@@ -511,6 +888,9 @@ interface LoadedEvent {
   mainListener?: EventListener;
   executedOnceListeners?: Set<ListenerFunction>;
 }
+/**
+ * Data structure representing loaded event information for external consumption.
+ */
 interface AppEventsHandlerLoadedData {
   name: string;
   namespace: string | null;
@@ -518,28 +898,99 @@ interface AppEventsHandlerLoadedData {
   regularListeners: number;
   metadata: ParsedEvent;
 }
+/**
+ * Handles Discord.js events and CommandKit custom events with support for namespacing and middleware.
+ */
 declare class AppEventsHandler {
   readonly commandkit: CommandKit;
+  /**
+   * @private
+   * @internal
+   */
   private loadedEvents;
+  /**
+   * Creates a new AppEventsHandler instance.
+   * @param commandkit - The CommandKit instance
+   */
   constructor(commandkit: CommandKit);
+  /**
+   * Gets information about all loaded events.
+   * @returns Array of loaded event data
+   */
   getEvents(): AppEventsHandlerLoadedData[];
+  /**
+   * Reloads all events by unregistering existing ones and loading them again.
+   */
   reloadEvents(): Promise<void>;
+  /**
+   * Loads all events from the events router and registers them with Discord.js client.
+   */
   loadEvents(): Promise<void>;
+  /**
+   * Unregisters all event listeners and clears loaded events.
+   */
   unregisterAll(): void;
+  /**
+   * Registers all loaded events with the Discord.js client and CommandKit event system.
+   */
   registerAllClientEvents(): void;
+  /**
+   * Unregisters all client event listeners and cleans up loaded events.
+   */
   unregisterAllClientListeners(): void;
 }
 //#endregion
 //#region src/utils/dev-hooks.d.ts
+/**
+ * Represents HMR inter-process communication messages.
+ */
+interface IpcMessageCommand {
+  /**
+   * The type of HMR event being communicated.
+   */
+  event: HMREventType;
+  /**
+   * The path associated with the HMR event.
+   */
+  path: string;
+  /**
+   * An optional identifier for the HMR event, used for acknowledgment.
+   */
+  id?: string;
+}
+/**
+ * Represents an HMR event in CommandKit.
+ */
 interface CommandKitHMREvent {
+  /**
+   * The type of HMR event.
+   */
   event: HMREventType;
+  /**
+   * The path associated with the HMR event.
+   */
   path: string;
+  /**
+   * Accepts the HMR event, indicating that it has been handled.
+   * This prevents further processing of the event.
+   */
   accept: () => void;
+  /**
+   * Prevents the default action for the HMR event.
+   * This can be used to stop further processing of the event.
+   */
   preventDefault: () => void;
 }
+/**
+ * Registers development hooks for CommandKit to handle HMR (Hot Module Replacement) events.
+ * @param commandkit - The CommandKit instance to register hooks for.
+ */
 declare function registerDevHooks(commandkit: CommandKit): void;
 //#endregion
 //#region src/plugins/RuntimePlugin.d.ts
+/**
+ * CommandKit plugin that runs at the runtime.
+ */
 declare abstract class RuntimePlugin<T extends PluginOptions = PluginOptions> extends PluginCommon<T, CommandKitPluginRuntime> {
   readonly type = PluginType.Runtime;
   /**
@@ -648,28 +1099,80 @@ declare abstract class RuntimePlugin<T extends PluginOptions = PluginOptions> ex
 declare function isRuntimePlugin(plugin: unknown): plugin is RuntimePlugin;
 //#endregion
 //#region src/plugins/types.d.ts
+/**
+ * Represents a CommandKit plugin that can be either a runtime or compiler plugin.
+ */
 type CommandKitPlugin = RuntimePlugin | CompilerPlugin;
+/**
+ * @private
+ */
 type MaybeFalsey<T> = T | false | null | undefined;
+/**
+ * Represents an event dispatched to the plugins.
+ */
 interface CommandKitEventDispatch {
+  /**
+   * The name of the event.
+   */
   name: string;
+  /**
+   * The arguments passed to the event.
+   */
   args: unknown[];
+  /**
+   * The namespace of the event, if any.
+   */
   namespace: string | null;
+  /**
+   * If this event runs only once, it will be set to true.
+   */
   once: boolean;
+  /**
+   * The additional metadata associated with the event.
+   */
   metadata: ParsedEvent;
+  /**
+   * Captures the owner of the event, preventing other plugins from handling it.
+   */
   accept(): void;
 }
+/**
+ * Represents a template handler function that can be used to handle templates using `commandkit create` command.
+ * @param args - The arguments passed to the template handler.
+ */
 type TemplateHandler = (args: string[]) => Promise<void> | void;
 //#endregion
 //#region src/plugins/CompilerPlugin.d.ts
+/**
+ * The parameters for the transformation function of a compiler plugin.
+ */
 interface PluginTransformParameters {
+  /**
+   * The code to be transformed.
+   */
   code: string;
+  /**
+   * The filename of the code being transformed.
+   */
   id: string;
 }
 interface TransformedResult {
+  /**
+   * The transformed code.
+   */
   code?: string;
+  /**
+   * The source map for the transformed code, if applicable.
+   */
   map?: string | null;
 }
+/**
+ * CommandKit plugin that runs at compile time.
+ */
 declare abstract class CompilerPlugin<T extends PluginOptions = PluginOptions> extends PluginCommon<T, CompilerPluginRuntime> {
+  /**
+   * The type of the plugin, which is Compiler.
+   */
   readonly type = PluginType.Compiler;
   /**
    * Called when transformation is requested to this plugin
@@ -678,12 +1181,27 @@ declare abstract class CompilerPlugin<T extends PluginOptions = PluginOptions> e
    */
   transform(params: PluginTransformParameters): Promise<MaybeFalsey<TransformedResult>>;
 }
+/**
+ * Type guard to check if the given object is a CompilerPlugin.
+ * @param plugin The object to check.
+ * @returns Boolean indicating whether the object is a CompilerPlugin.
+ */
 declare function isCompilerPlugin(plugin: unknown): plugin is CompilerPlugin;
 //#endregion
 //#region src/plugins/plugin-runtime/builtin/CommonDirectiveTransformer.d.ts
+/**
+ * Directive transformer plugin options
+ */
 type CommonDirectiveTransformerOptions = DirectiveTransformerOptions & {
+  /**
+   * Whether the directive transformer is enabled.
+   * Defaults to true.
+   */
   enabled?: boolean;
 };
+/**
+ * Common directive transformer plugin is a compiler plugin that transforms directives to higher-order functions.
+ */
 declare abstract class CommonDirectiveTransformer extends CompilerPlugin<CommonDirectiveTransformerOptions> {
   private transformer;
   activate(ctx: CompilerPluginRuntime): Promise<void>;
@@ -692,25 +1210,78 @@ declare abstract class CommonDirectiveTransformer extends CompilerPlugin<CommonD
 }
 //#endregion
 //#region src/plugins/plugin-runtime/CompilerPluginRuntime.d.ts
+/**
+ * CompilerPluginRuntime is a runtime for managing compiler plugins in CommandKit.
+ */
 declare class CompilerPluginRuntime {
   #private;
   private readonly plugins;
   readonly name = "CompilerPluginRuntime";
   private initialized;
   private templates;
+  /**
+   * Creates a new instance of CompilerPluginRuntime.
+   * @param plugins An array of compiler plugins to be managed by this runtime.
+   */
   constructor(plugins: CompilerPlugin[]);
+  /**
+   * Returns the plugins managed by this runtime.
+   */
   getPlugins(): CompilerPlugin<PluginOptions>[];
+  /**
+   * Checks if there are no plugins registered in this runtime.
+   */
   isEmpty(): boolean;
+  /**
+   * Registers a template handler for a given name.
+   * This method must be called inside the activate() method of a plugin.
+   * @param name - The name of the template to register.
+   * @param handler - The handler function for the template.
+   */
   registerTemplate(name: string, handler: TemplateHandler): void;
+  /**
+   * Unregisters a template handler for a given name.
+   * This method must be called inside the deactivate() method of a plugin.
+   * @param name - The name of the template to unregister.
+   */
   unregisterTemplate(name: string): void;
+  /**
+   * Retrieves a template handler by its name.
+   * @param name - The name of the template to retrieve.
+   * @returns The template handler if found, otherwise undefined.
+   */
   getTemplate(name: string): TemplateHandler | undefined;
+  /**
+   * Returns a map of all registered templates with their handlers.
+   * The keys are the template names and the values are the template handlers.
+   */
   getTemplates(): Map<string, TemplateHandler>;
+  /**
+   * Transforms the given code using all registered plugins.
+   * Each plugin's transform method is called in sequence, allowing them to modify the code.
+   * @param code - The code to be transformed.
+   * @param id - The identifier for the code being transformed (e.g., filename).
+   * @returns An object containing the transformed code and an optional source map.
+   */
   transform(code: string, id: string): Promise<{
     code: string;
     map: string | null;
   }>;
+  /**
+   * Initializes the plugin runtime by activating all registered plugins.
+   * This method should be called once to set up the plugins.
+   */
   init(): Promise<void>;
+  /**
+   * Destroys the plugin runtime by deactivating all registered plugins.
+   * This method should be called when the runtime is no longer needed.
+   */
   destroy(): Promise<void>;
+  /**
+   * Converts the plugin runtime to a JSON representation.
+   * This is useful for serialization or debugging purposes.
+   * @returns An object containing the name of the runtime and the transform method.
+   */
   toJSON(): {
     name: string;
     transform: (code: string, id: string) => Promise<{
@@ -721,20 +1292,49 @@ declare class CompilerPluginRuntime {
 }
 //#endregion
 //#region src/plugins/plugin-runtime/runtime.d.ts
+/**
+ * Common plugin runtime type that can be used in both command and compiler plugins.
+ */
 type CommonPluginRuntime = CommandKitPluginRuntime | CompilerPluginRuntime;
 //#endregion
 //#region src/plugins/PluginCommon.d.ts
+/**
+ * The options for a CommandKit plugin.
+ */
 type PluginOptions = Record<string, any>;
+/**
+ * Enum representing the type of plugin.
+ * - Compiler: A plugin that runs at compile time.
+ * - Runtime: A plugin that runs at runtime.
+ */
 declare enum PluginType {
   Compiler = "compiler",
   Runtime = "runtime",
 }
+/**
+ * Base class for CommandKit plugins.
+ */
 declare abstract class PluginCommon<T extends PluginOptions = PluginOptions, C extends CommonPluginRuntime = CommonPluginRuntime> {
   protected readonly options: T;
+  /**
+   * The type of the plugin, either Compiler or Runtime.
+   */
   abstract readonly type: PluginType;
+  /**
+   * Unique identifier for the plugin instance.
+   */
   readonly id: `${string}-${string}-${string}-${string}-${string}`;
+  /**
+   * The time when the plugin was loaded, in milliseconds since the Unix epoch.
+   */
   readonly loadedAt: number;
+  /**
+   * The name of the plugin.
+   */
   abstract readonly name: string;
+  /**
+   * Creates a new instance of the plugin.
+   */
   constructor(options: T);
   /**
    * Called when this plugin is activated
@@ -745,20 +1345,65 @@ declare abstract class PluginCommon<T extends PluginOptions = PluginOptions, C e
    */
   deactivate(ctx: C): Promise<void>;
 }
+/**
+ * Whether the given object is a CommandKit plugin.
+ * @param plugin The object to check.
+ * @returns Boolean indicating whether the object is a plugin.
+ */
 declare function isPlugin(plugin: unknown): plugin is PluginCommon<PluginOptions>;
 //#endregion
 //#region src/plugins/plugin-runtime/CommandKitPluginRuntime.d.ts
+/**
+ * Represents the runtime environment for CommandKit plugins.
+ */
 declare class CommandKitPluginRuntime {
   readonly commandkit: CommandKit;
   private plugins;
+  /**
+   * Creates a new instance of CommandKitPluginRuntime.
+   * @param commandkit The CommandKit instance associated with this runtime.
+   */
   constructor(commandkit: CommandKit);
+  /**
+   * Returns the plugins registered in this runtime.
+   * @returns A collection of plugins.
+   */
   getPlugins(): Collection<string, RuntimePlugin<PluginOptions>>;
+  /**
+   * Checks if there are no plugins registered in this runtime.
+   * @returns Boolean indicating whether the runtime is empty.
+   */
   getPlugin(pluginName: string): RuntimePlugin | null;
+  /**
+   * Soft registers a plugin in the runtime.
+   * @param plugin The plugin to be registered.
+   */
   softRegisterPlugin(plugin: RuntimePlugin): Promise<void>;
+  /**
+   * Registers a plugin in the runtime.
+   * @param plugin The plugin to be registered.
+   * @throws If a plugin with the same name already exists.
+   */
   registerPlugin(plugin: RuntimePlugin): Promise<void>;
+  /**
+   * Unregisters a plugin from the runtime.
+   * @param plugin The plugin to be unregistered.
+   * @throws If the plugin does not exist.
+   */
   unregisterPlugin(plugin: RuntimePlugin): Promise<void>;
+  /**
+   * Unregisters all plugins from the runtime.
+   */
   unregisterAllPlugins(): Promise<void>;
+  /**
+   * Signals the runtime to allow the current plugin take ownership of the execution context.
+   */
   capture(): void;
+  /**
+   * Executes a function for each plugin in the runtime.
+   * @param f The function to execute for each plugin.
+   * @returns The result of the last executed function, or undefined if no plugins were executed.
+   */
   execute<R = any>(f: AsyncFunction<[CommandKitPluginRuntime, RuntimePlugin], R | undefined>): Promise<true | R | undefined>;
 }
 //#endregion
@@ -834,6 +1479,9 @@ declare class JsonFlagProvider implements FlagProvider {
  * Set the global flag provider for all feature flags
  */
 declare function setFlagProvider(provider: FlagProvider): void;
+/**
+ * @private
+ */
 type MaybePromise<T> = T | Promise<T>;
 /**
  * Function type for identifying entities in the context of feature flags.
@@ -887,6 +1535,9 @@ interface FeatureFlagDefinition<R, Entity> {
    */
   disableAnalytics?: boolean;
 }
+/**
+ * Context for evaluating command flags in CommandKit.
+ */
 interface CommandFlagContext {
   /**
    * The Discord client instance.
@@ -934,6 +1585,9 @@ interface CommandFlagContext {
    */
   event: null;
 }
+/**
+ * Context for evaluating event flags in CommandKit.
+ */
 interface EventFlagContext {
   /**
    * The Discord client instance.
@@ -1050,40 +1704,128 @@ declare class FeatureFlag<R, T> {
 declare function flag<Returns = boolean, Entity = Record<any, any>>(options: FeatureFlagDefinition<Returns, Entity>): FlagRunner<Entity, Returns>;
 //#endregion
 //#region src/flags/store.d.ts
+/**
+ * Represents a store for feature flags.
+ * This store extends the Collection class to manage feature flags by their keys.
+ */
 declare class FlagStore extends Collection<string, FeatureFlag<any, any>> {}
 //#endregion
 //#region src/analytics/analytics-provider.d.ts
+/**
+ * AnalyticsEvent interface represents an event that can be tracked by an analytics provider.
+ * It includes the event name, an optional unique identifier, and a data object containing event-specific information.
+ */
 interface AnalyticsEvent {
   name: string;
   id?: string;
   data: Record<string, any>;
 }
+/**
+ * IdentifyEvent interface represents an event used to identify a user or entity in the analytics system.
+ */
 type IdentifyEvent = Record<string, any>;
+/**
+ * AnalyticsProvider interface defines the contract for analytics providers.
+ */
 interface AnalyticsProvider {
+  /**
+   * The name of the analytics provider.
+   * This is used for logging and identification purposes.
+   */
   readonly name: string;
+  /**
+   * Initializes the analytics provider.
+   * This method is called when the provider is registered.
+   */
   track(engine: AnalyticsEngine, event: AnalyticsEvent): Promise<void>;
+  /**
+   * Identifies a user or entity with the analytics provider.
+   * This method is called to associate user data with events.
+   */
   identify?(engine: AnalyticsEngine, event: IdentifyEvent): Promise<void>;
 }
 //#endregion
 //#region src/analytics/analytics-engine.d.ts
+/**
+ * Filter function type for analytics events.
+ * @param engine The analytics engine instance.
+ * @param event The analytics event to filter.
+ * @returns A boolean indicating whether the event should be tracked.
+ */
 type FilterFunction = (engine: AnalyticsEngine, event: AnalyticsEvent) => boolean;
+/**
+ * AnalyticsEngine class for managing analytics providers and tracking events.
+ * This class allows you to register a provider, set a filter for events, and track or identify events.
+ */
 declare class AnalyticsEngine {
   #private;
   readonly commandkit: CommandKit;
+  /**
+   * Creates an instance of the AnalyticsEngine.
+   * @param commandkit The CommandKit instance.
+   */
   constructor(commandkit: CommandKit);
+  /**
+   * Sets a filter function for analytics events.
+   * This function will be called before tracking an event to determine if it should be tracked.
+   * If the filter returns `false`, the event will not be tracked.
+   * If the filter is set to `null`, all events will be tracked unless `doNotTrack` is enabled.
+   * @param filter The filter function to set, or `null` to remove the filter.
+   */
   setFilter(filter: FilterFunction | null): void;
+  /**
+   * Registers an analytics provider.
+   * This provider will be used to track and identify events.
+   * If a provider is already registered, it will be replaced with the new one.
+   * @param provider The analytics provider to register.
+   */
   registerProvider(provider: AnalyticsProvider): void;
+  /**
+   * Removes the currently registered analytics provider.
+   * @param provider The analytics provider to remove.
+   */
   removeProvider(provider: AnalyticsProvider): void;
+  /**
+   * Retrieves the currently registered analytics provider.
+   * @returns The currently registered analytics provider, or `null` if no provider is registered.
+   */
   getProvider(): AnalyticsProvider | null;
+  /**
+   * Identifies a user with the analytics provider.
+   * This method sends an identify event to the provider, which can be used to associate user data with events.
+   * @param event The identify event containing user data to send to the provider.
+   */
   identify(event: IdentifyEvent): Promise<void>;
+  /**
+   * Tracks an analytics event with the registered provider.
+   * This method sends the event to the provider, which can then process it as needed.
+   * If the `doNotTrack` setting is enabled or if the filter function returns `false`, the event will not be tracked.
+   * @param event The analytics event to track.
+   */
   track(event: AnalyticsEvent): Promise<void>;
 }
 //#endregion
 //#region src/CommandKit.d.ts
+/**
+ * Configurations for the CommandKit instance.
+ */
 interface CommandKitConfiguration {
+  /**
+   * The default locale for the CommandKit instance. This will be used to infer the locale of the guild or user if it has not been set explicitly.
+   * @default Locale.EnglishUS
+   */
   defaultLocale: Locale;
+  /**
+   * A function that returns the command prefix for a given message.
+   * This is used to determine how to parse commands from messages.
+   * @param message The message to get the command prefix for.
+   * @returns The command prefix or an array of prefixes.
+   */
   getMessageCommandPrefix: (message: Message) => Awaitable<string | string[]>;
 }
+/**
+ * Represents the function executed during the bootstrap phase of CommandKit.
+ */
 type BootstrapFunction = GenericFunction<[CommandKit]> | AsyncFunction<[CommandKit]>;
 /**
  * Registers a bootstrap hook that will be called when the CommandKit instance is created.
@@ -1113,25 +1855,72 @@ declare function onBootstrap<F extends BootstrapFunction>(fn: F): void;
  * ```
  */
 declare function onApplicationBootstrap<F extends BootstrapFunction>(fn: F): void;
+/**
+ * The commandkit class that serves as the main entry point for the CommandKit framework.
+ */
 declare class CommandKit extends EventEmitter {
   #private;
+  /**
+   * The event interceptor to quickly register temporary event listeners
+   */
   eventInterceptor: EventInterceptor;
+  /**
+   * The static createElement function to create jsx elements
+   */
   static readonly createElement: typeof createElement;
+  /**
+   * The static Fragment component to create jsx fragments
+   */
   static readonly Fragment: typeof Fragment;
+  /**
+   * The configuration for the CommandKit instance.
+   */
   readonly config: CommandKitConfiguration;
+  /**
+   * A key-value store for storing arbitrary data.
+   */
   readonly store: Map<string, any>;
+  /**
+   * A flag store for storing flags that can be used to enable or disable features.
+   */
   readonly flags: FlagStore;
+  /**
+   * The command router for the CommandKit instance.
+   */
   commandsRouter: CommandsRouter;
+  /**
+   * The events router for the CommandKit instance.
+   */
   eventsRouter: EventsRouter;
+  /**
+   * The command handler for the CommandKit instance.
+   * This is responsible for handling commands and their execution.
+   */
   commandHandler: AppCommandHandler;
+  /**
+   * The event handler for the CommandKit instance.
+   * This is responsible for handling events and their execution.
+   */
   eventHandler: AppEventsHandler;
+  /**
+   * The plugins runtime for the CommandKit instance.
+   */
   plugins: CommandKitPluginRuntime;
+  /**
+   * The events channel for the CommandKit instance. This can be used to emit custom events.
+   */
   events: CommandKitEventsChannel;
+  /**
+   * The analytics engine for the CommandKit instance.
+   * This is responsible for tracking events and user interactions.
+   */
   analytics: AnalyticsEngine;
+  /**
+   * The static instance of CommandKit.
+   */
   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}
    */
@@ -1191,9 +1980,17 @@ declare class CommandKit extends EventEmitter {
    * - `./src/app`
    */
   getAppDirectory(): string | null;
+  /**
+   * Get the path to the commands or events directory.
+   * @param to The type of path to get, either 'commands' or 'events'.
+   * @returns The path to the commands or events directory
+   */
   getPath(to: 'commands' | 'events'): string | null;
 }
+/**
+ * The singleton instance of CommandKit.
+ */
 declare const commandkit: CommandKit;
 //#endregion
-export { AnalyticsEngine, AnalyticsEvent, AnalyticsProvider, 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, FilterFunction, FlagConfiguration, FlagProvider, FlagRunner, FlagStore, GenericFunction, IdentifyEvent, IdentifyFunction, InteractionCommandContext, InteractionCommandMiddlewareContext, JsonFlagProvider, ListenerFunction, LoadedCommand, LoadedEvent, MaybeFalsey, MaybePromise, MessageCommand, MessageCommandContext, MessageCommandMiddlewareContext, MessageContextMenuCommand, MessageContextMenuCommandContext, MessageContextMenuCommandMiddlewareContext, MiddlewareContext, MiddlewareContextArgs, PluginCommon, PluginOptions, PluginTransformParameters, PluginType, PreRegisterCommandsEvent, PreparedAppCommandExecution, ResolvableCommand, RunCommand, RuntimePlugin, SlashCommandMiddlewareContext, TemplateHandler, TransformedResult, UserContextMenuCommand, UserContextMenuCommandContext, UserContextMenuCommandMiddlewareContext, after, cancelAfter, commandkit, exitContext, flag, getCommandKit, getContext, isCommandWorkerContext, isCompilerPlugin, isPlugin, isRuntimePlugin, makeContextAwareFunction, onApplicationBootstrap, onBootstrap, provideContext, registerDevHooks, setFlagProvider, useEnvironment };
-//# sourceMappingURL=CommandKit-B-mjdP5x.d.ts.map
+export { AnalyticsEngine, AnalyticsEvent, AnalyticsProvider, 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, FilterFunction, FlagConfiguration, FlagProvider, FlagRunner, FlagStore, GenericFunction, IdentifyEvent, IdentifyFunction, InteractionCommandContext, InteractionCommandMiddlewareContext, IpcMessageCommand, JsonFlagProvider, ListenerFunction, LoadedCommand, LoadedEvent, MaybeFalsey, MaybePromise, MessageCommand, MessageCommandContext, MessageCommandMiddlewareContext, MessageContextMenuCommand, MessageContextMenuCommandContext, MessageContextMenuCommandMiddlewareContext, MiddlewareContext, MiddlewareContextArgs, PluginCommon, PluginOptions, PluginTransformParameters, PluginType, PreRegisterCommandsEvent, PreparedAppCommandExecution, ResolvableCommand, RunCommand, RuntimePlugin, SlashCommandMiddlewareContext, TemplateHandler, TransformedResult, UserContextMenuCommand, UserContextMenuCommandContext, UserContextMenuCommandMiddlewareContext, after, cancelAfter, commandkit, exitContext, flag, getCommandKit, getContext, isCommandWorkerContext, isCompilerPlugin, isPlugin, isRuntimePlugin, makeContextAwareFunction, onApplicationBootstrap, onBootstrap, provideContext, registerDevHooks, setFlagProvider, useEnvironment };
+//# sourceMappingURL=CommandKit-BkMUDbou.d.ts.map