commandkit 1.2.0-rc.12 → 1.2.0-rc.13

package/dist/{analytics-engine-NOInIjv8.d.ts → analytics-engine-WQhXmx3H.d.ts}

@@ -1,14 +1,14 @@
-import { EventInterceptor } from "./EventInterceptor-x-R2qshQ.js";
-import { Fragment, createElement } from "./element-CvNhvLZ8.js";
-import { MaybeArray } from "./types-CJ-XvOFN.js";
-import { MessageCommandOptions, MessageCommandParser } from "./MessageCommandParser-DEOl_ifb.js";
-import { Command, CommandsRouter, Middleware } from "./CommandsRouter-CBdsqaWK.js";
-import { EventsRouter, ParsedEvent } from "./EventsRouter-4pT6vj-U.js";
-import { HMREventType } from "./constants-DqnSDZ6l.js";
+import { t as EventInterceptor } from "./EventInterceptor-CZmWpS08.js";
+import { a as Fragment, s as createElement } from "./element-wQo0heGj.js";
+import { t as MaybeArray } from "./types-BywA9d2Z.js";
+import { r as MessageCommandParser, t as MessageCommandOptions } from "./MessageCommandParser-q3dQcE5N.js";
+import { i as Middleware, n as CommandsRouter, t as Command } from "./CommandsRouter-C7dZEepB.js";
+import { i as ParsedEvent, t as EventsRouter } from "./EventsRouter-DZ37r54v.js";
+import { o as HMREventType } from "./constants-CuYW0K10.js";
 import EventEmitter from "node:events";
 import { AutocompleteInteraction, Awaitable, CacheType, ChatInputCommandInteraction, Client, ClientEvents, Collection, Constructable, ContextMenuCommandBuilder, ContextMenuCommandInteraction, Guild, Interaction, Locale, Message, MessageContextMenuCommandInteraction, PermissionsString, RESTPostAPIApplicationCommandsJSONBody, SlashCommandBuilder, TextBasedChannel, UserContextMenuCommandInteraction } from "discord.js";
 import { DirectiveTransformerOptions } from "directive-to-hof";
-import { Options } from "tsdown";
+import { InlineConfig } from "tsdown";
 
 //#region src/types.d.ts
 type Prettify<T> = { [K in keyof T]: T[K] } & {};
@@ -17,8 +17,8 @@ type Prettify<T> = { [K in keyof T]: T[K] } & {};
  */
 interface CommandKitOptions {
   /**
-   * The Discord.js client object to use with CommandKit.
-   */
+       * The Discord.js client object to use with CommandKit.
+       */
   client?: Client;
 }
 /**
@@ -26,16 +26,16 @@ interface CommandKitOptions {
  */
 interface CommandContext<T extends Interaction, Cached extends CacheType> {
   /**
-   * The interaction that triggered this command.
-   */
+       * The interaction that triggered this command.
+       */
   interaction: Interaction<CacheType>;
   /**
-   * The client that instantiated this command.
-   */
+       * The client that instantiated this command.
+       */
   client: Client;
   /**
-   * The command data.
-   */
+       * The command data.
+       */
   handler: CommandKit;
 }
 /**
@@ -43,24 +43,24 @@ interface CommandContext<T extends Interaction, Cached extends CacheType> {
  */
 interface CommandMetadata {
   /**
-   * The guilds that the command is available in.
-   */
+       * The guilds that the command is available in.
+       */
   guilds?: string[];
   /**
-   * The aliases of the command.
-   */
+       * The aliases of the command.
+       */
   aliases?: string[];
   /**
-   * The user permissions required to execute the command.
-   */
+       * The user permissions required to execute the command.
+       */
   userPermissions?: PermissionsString | PermissionsString[];
   /**
-   * The bot permissions required to execute the command.
-   */
+       * The bot permissions required to execute the command.
+       */
   botPermissions?: PermissionsString | PermissionsString[];
   /**
-   * The name aliases for the `user` and `message` context menu commands. When i18n plugin is in use, this option will be ignored if the translation for the context menu command name is provided.
-   */
+       * The name aliases for the `user` and `message` context menu commands. When i18n plugin is in use, this option will be ignored if the translation for the context menu command name is provided.
+       */
   nameAliases?: Record<'user' | 'message', string>;
 }
 /**
@@ -68,8 +68,8 @@ interface CommandMetadata {
  */
 type CommandData = Prettify<Omit<RESTPostAPIApplicationCommandsJSONBody, 'description'> & {
   /**
-   * The description of the command.
-   */
+       * The description of the command.
+       */
   description?: string;
 }>;
 /**
@@ -201,138 +201,138 @@ declare class Context<ExecutionMode extends CommandExecutionMode = CommandExecut
   readonly commandkit: CommandKit;
   protected readonly config: ContextParameters<ExecutionMode, Args>;
   /**
-   * The interaction that triggered the command.
-   */
+       * The interaction that triggered the command.
+       */
   readonly interaction: ContextParameters<ExecutionMode>['interaction'];
   /**
-   * The message that triggered the command.
-   */
+       * The message that triggered the command.
+       */
   readonly message: ContextParameters<ExecutionMode>['message'];
   /**
-   * The guild where the command was triggered.
-   */
+       * The guild where the command was triggered.
+       */
   readonly guild: Guild | null;
   /**
-   * The guild ID where the command was triggered.
-   */
+       * The guild ID where the command was triggered.
+       */
   readonly guildId: string | null;
   /**
-   * The channel where the command was triggered.
-   */
+       * The channel where the command was triggered.
+       */
   readonly channel: TextBasedChannel | null;
   /**
-   * The channel id where the command was triggered.
-   */
+       * The channel id where the command was triggered.
+       */
   readonly channelId: string | null;
   /**
-   * The client instance.
-   */
+       * The client instance.
+       */
   readonly client: Client;
   /**
-   * The command that this context belongs to.
-   */
+       * The command that this context belongs to.
+       */
   readonly command: LoadedCommand;
   /**
-   * @private
-   * @internal
-   */
+       * @private
+       * @internal
+       */
   private _locale;
   /**
-   * Creates a new command context.
-   * @param commandkit The command kit instance.
-   * @param config The context parameters.
-   */
+       * 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.
-   */
+       * 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(): Collection<any, any>;
   /**
-   * Gets the name of the current command.
-   */
+       * Gets the name of the current command.
+       */
   get commandName(): string;
   /**
-   * Gets the invoked command name (could be an alias for message commands)
-   */
+       * Gets the invoked command name (could be an alias for message commands)
+       */
   get invokedCommandName(): string;
   /**
-   * Gets the command options based on the execution mode.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * The execution mode of the command.
+       */
   get executionMode(): ExecutionMode;
   /**
-   * Whether the command was triggered by an interaction.
-   */
+       * Whether the command was triggered by an interaction.
+       */
   isInteraction(): this is InteractionCommandContext;
   /**
-   * Whether the command was triggered by a slash command interaction.
-   */
+       * Whether the command was triggered by a slash command interaction.
+       */
   isChatInputCommand(): this is ChatInputCommandContext;
   /**
-   * Whether the command was triggered by an autocomplete interaction.
-   */
+       * Whether the command was triggered by an autocomplete interaction.
+       */
   isAutocomplete(): this is AutocompleteCommandContext;
   /**
-   * Whether the command was triggered by a message context menu interaction.
-   */
+       * 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.
-   */
+       * Whether the command was triggered by a user context menu interaction.
+       */
   isUserContextMenu(): this is UserContextMenuCommandContext;
   /**
-   * Whether the command was triggered by a message.
-   */
+       * Whether the command was triggered by a message.
+       */
   isMessage(): this is Context<'message'>;
   /**
-   * Returns the command identifier.
-   */
+       * Returns the command identifier.
+       */
   getCommandIdentifier(): string;
   /**
-   * Returns the locale of the guild where this command was triggered.
-   */
+       * Returns the locale of the guild where this command was triggered.
+       */
   getGuildLocale(): Locale | null;
   /**
-   * Returns the locale of the user who triggered this command.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * Sets the locale for this command.
+       * @param locale The locale to set.
+       */
   setLocale(locale: Locale | null): void;
   /**
-   * Creates a clone of this context
-   * @param config - Optional partial config to override in the clone
-   */
+       * 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.
-   */
+       * 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
-   */
+       * Gets the command arguments (only available for message commands).
+       * @returns Array of command arguments
+       */
   args(): string[];
 }
 /**
@@ -340,14 +340,14 @@ declare class Context<ExecutionMode extends CommandExecutionMode = CommandExecut
  */
 declare class MiddlewareContext<T extends CommandExecutionMode = CommandExecutionMode> extends Context<T, MiddlewareContextArgs> {
   /**
-   * 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
-   * })
-   */
+       * 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
@@ -365,36 +365,36 @@ interface PreRegisterCommandsEvent {
 declare class CommandRegistrar {
   readonly commandkit: CommandKit;
   /**
-   * @private
-   * @internal
-   */
+       * @private
+       * @internal
+       */
   private api;
   /**
-   * Creates an instance of CommandRegistrar.
-   * @param commandkit The commandkit instance.
-   */
+       * Creates an instance of CommandRegistrar.
+       * @param commandkit The commandkit instance.
+       */
   constructor(commandkit: CommandKit);
   /**
-   * Gets the commands data.
-   */
+       * Gets the commands data.
+       */
   getCommandsData(): (CommandData & {
     __metadata?: CommandMetadata;
     __applyId(id: string): void;
   })[];
   /**
-   * Registers loaded commands.
-   */
+       * Registers loaded commands.
+       */
   register(): Promise<void>;
   /**
-   * Updates the global commands.
-   */
+       * Updates the global commands.
+       */
   updateGlobalCommands(commands: (CommandData & {
     __metadata?: CommandMetadata;
     __applyId(id: string): void;
   })[]): Promise<void>;
   /**
-   * Updates the guild commands.
-   */
+       * Updates the guild commands.
+       */
   updateGuildCommands(commands: (CommandData & {
     __metadata?: CommandMetadata;
     __applyId(id: string): void;
@@ -407,46 +407,46 @@ declare class CommandRegistrar {
  */
 interface CommandKitEnvironmentInternalData {
   /**
-   * The error that occurred during command execution, if any.
-   * This is set when an error occurs during the execution of a command.
-   */
+       * 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.).
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * The start time of the command execution.
+       */
   markStart: number;
   /**
-   * The end time of the command execution.
-   */
+       * 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.
-   */
+       * The context associated with the command execution.
+       * This can be used to access request-specific data or application state.
+       */
   context: Context | null;
   /**
-   * Shared collection instance for arbitrary data storage
-   */
+       * Shared collection instance for arbitrary data storage
+       */
   store: Collection<any, any>;
 }
 /**
@@ -456,92 +456,92 @@ declare class CommandKitEnvironment {
   #private;
   readonly commandkit: CommandKit;
   /**
-   * Creates the commandkit execution environment.
-   * @param commandkit - The commandkit instance.
-   */
+       * Creates the commandkit execution environment.
+       * @param commandkit - The commandkit instance.
+       */
   constructor(commandkit: CommandKit);
   /**
-   * Set the context.
-   * @param context - The context to set.
-   */
+       * Set the context.
+       * @param context - The context to set.
+       */
   setContext(context: Context): void;
   /**
-   * Get the context. `null` if not set.
-   * @internal
-   */
+       * Get the context. `null` if not set.
+       * @internal
+       */
   get context(): Context | null;
   /**
-   * Get the execution error.
-   * @internal
-   */
+       * Get the execution error.
+       * @internal
+       */
   getExecutionError(): Error | null;
   /**
-   * Set the execution error.
-   * @param error - The error to set.
-   * @internal
-   */
+       * Set the execution error.
+       * @param error - The error to set.
+       * @internal
+       */
   setExecutionError(error: Error): void;
   /**
-   * Get the environment type.
-   */
+       * Get the environment type.
+       */
   getType(): CommandKitEnvironmentType;
   /**
-   * Set the environment type.
-   * @param type - The environment type to set.
-   * @internal
-   */
+       * Set the environment type.
+       * @param type - The environment type to set.
+       * @internal
+       */
   setType(type: CommandKitEnvironmentType): void;
   /**
-   * The variables store for this environment.
-   */
+       * The variables store for this environment.
+       */
   get variables(): Map<string, any>;
   /**
-   * The shared store for this environment
-   */
+       * The shared store for this environment
+       */
   get store(): Collection<any, any>;
   /**
-   * Register a deferred function.
-   * @param fn - The deferred function to register.
-   * @returns The deferred function id.
-   * @internal
-   */
+       * 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
-   */
+       * 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
-   */
+       * Run all deferred functions sequentially.
+       * @internal
+       */
   runDeferredFunctions(): Promise<void>;
   /**
-   * Clear all deferred functions.
-   * @internal
-   */
+       * Clear all deferred functions.
+       * @internal
+       */
   clearAllDeferredFunctions(): void;
   /**
-   * Mark the start of a command execution.
-   * @param marker - The marker to set.
-   * @internal
-   */
+       * 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
-   */
+       * Mark the end of a command execution.
+       * @internal
+       */
   markEnd(): void;
   /**
-   * Get the marker.
-   * @internal
-   */
+       * Get the marker.
+       * @internal
+       */
   getMarker(): string;
   /**
-   * Get the execution time in milliseconds.
-   * @internal
-   */
+       * Get the execution time in milliseconds.
+       * @internal
+       */
   getExecutionTime(): number;
 }
 declare enum CommandKitEnvironmentType {
@@ -640,17 +640,17 @@ declare function useStore(): Collection<any, any>;
  */
 interface RunCommandOptions {
   /**
-   * The handler to use for executing the command.
-   * If not provided, the execution mode will determine the handler.
-   * For example, 'chatInputCommand', 'message', etc.
-   */
+       * The handler to use for executing the command.
+       * If not provided, the execution mode will determine the handler.
+       * For example, 'chatInputCommand', 'message', etc.
+       */
   handler?: string;
   /**
-   * Whether to throw an error if the command execution fails.
-   * If true, any error during execution will be thrown.
-   * Default is false, which means errors will be logged but not thrown.
-   * @default false
-   */
+       * Whether to throw an error if the command execution fails.
+       * If true, any error during execution will be thrown.
+       * Default is false, which means errors will be logged but not thrown.
+       * @default false
+       */
   throwOnError?: boolean;
 }
 /**
@@ -661,23 +661,23 @@ declare class AppCommandRunner {
   #private;
   private handler;
   /**
-   * Creates a new AppCommandRunner instance.
-   * @param handler - The app command handler instance to use for command execution
-   */
+       * 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
-   * @param options - The options for running the command
-   */
+       * 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
+       * @param options - The options for running the command
+       */
   runCommand(prepared: PreparedAppCommandExecution, source: Interaction | Message, options?: RunCommandOptions): Promise<any>;
   /**
-   * 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
-   */
+       * 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
@@ -726,21 +726,21 @@ interface AppCommandMiddleware {
  */
 interface LoadedCommand {
   /**
-   * The associated discord snowflake id for this command.
-   * If the information is not yet available, this will be `null`.
-   */
+       * The associated discord snowflake id for this command.
+       * If the information is not yet available, this will be `null`.
+       */
   discordId: string | null;
   /**
-   * The command data.
-   */
+       * The command data.
+       */
   command: Command;
   /**
-   * The metadata for this command.
-   */
+       * The metadata for this command.
+       */
   metadata: CommandMetadata;
   /**
-   * The data for this command.
-   */
+       * The data for this command.
+       */
   data: AppCommand;
 }
 /**
@@ -805,118 +805,118 @@ type CommandDataSchemaValue = CommandDataSchema[CommandDataSchemaKey];
 declare class AppCommandHandler {
   readonly commandkit: CommandKit;
   /**
-   * @private
-   * @internal
-   */
+       * @private
+       * @internal
+       */
   private loadedCommands;
   /**
-   * @private
-   * @internal
-   */
+       * @private
+       * @internal
+       */
   private loadedMiddlewares;
   /**
-   * Command registrar for handling Discord API registration.
-   */
+       * Command registrar for handling Discord API registration.
+       */
   readonly registrar: CommandRegistrar;
   /**
-   * @private
-   * @internal
-   */
+       * @private
+       * @internal
+       */
   private onInteraction;
   /**
-   * @private
-   * @internal
-   */
+       * @private
+       * @internal
+       */
   private onMessageCreate;
   /**
-   * Command runner instance for executing commands.
-   */
+       * Command runner instance for executing commands.
+       */
   readonly commandRunner: AppCommandRunner;
   /**
-   * External command data storage.
-   */
+       * External command data storage.
+       */
   readonly externalCommandData: Collection<string, Command>;
   /**
-   * External middleware data storage.
-   */
+       * External middleware data storage.
+       */
   readonly externalMiddlewareData: Collection<string, Middleware>;
   /**
-   * Creates a new AppCommandHandler instance.
-   * @param commandkit - The CommandKit instance
-   */
+       * Creates a new AppCommandHandler instance.
+       * @param commandkit - The CommandKit instance
+       */
   constructor(commandkit: CommandKit);
   /**
-   * Prints a formatted banner showing all loaded commands organized by category.
-   */
+       * 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
-   */
+       * Gets an array of all loaded commands.
+       * @returns Array of loaded commands
+       */
   getCommandsArray(): LoadedCommand[];
   /**
-   * Registers event handlers for Discord interactions and messages.
-   */
+       * 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
-   */
+       * 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>;
   /**
-   * Finds a command by name.
-   * @param name - The command name to search for
-   * @param hint - The hint for the command type (user or message)
-   * @returns The loaded command or null if not found
-   */
+       * Finds a command by name.
+       * @param name - The command name to search for
+       * @param hint - The hint for the command type (user or message)
+       * @returns The loaded command or null if not found
+       */
   private findCommandByName;
   resolveMessageCommandName(name: string): string;
   /**
-   * Reloads all commands and middleware from scratch.
-   */
+       * 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
-   */
+       * 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
-   */
+       * 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
-   */
+       * 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
-   */
+       * 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.
-   */
+       * Loads all commands and middleware from the router.
+       */
   loadCommands(): Promise<void>;
   /**
-   * @private
-   * @internal
-   */
+       * @private
+       * @internal
+       */
   private loadMiddleware;
   /**
-   * @private
-   * @internal
-   */
+       * @private
+       * @internal
+       */
   private loadCommand;
   /**
-   * Gets the metadata for a command.
-   * @param command - The command name to get metadata for
-   * @param hint - The hint for the command type (user or message)
-   * @returns The command metadata or null if not found
-   */
+       * Gets the metadata for a command.
+       * @param command - The command name to get metadata for
+       * @param hint - The hint for the command type (user or message)
+       * @returns The command metadata or null if not found
+       */
   getMetadataFor(command: string, hint?: 'user' | 'message'): CommandMetadata | null;
 }
 //#endregion
@@ -934,18 +934,18 @@ declare class CommandKitEventsChannel {
   readonly commandkit: CommandKit;
   private emitter;
   /**
-   * Creates a new instance of CommandKitEventsChannel.
-   * @param commandkit The CommandKit instance that this channel belongs to.
-   */
+       * 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);
-   */
+       * 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;
@@ -954,40 +954,40 @@ declare class CommandKitEventsChannel {
     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.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * 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 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.
-   */
+       * 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;
 }
@@ -999,6 +999,7 @@ declare class CommandKitEventsChannel {
 type EventListener = {
   handler: ListenerFunction;
   once: boolean;
+  parallel: boolean;
 };
 /**
  * Represents a loaded event with all its listeners.
@@ -1027,39 +1028,39 @@ interface AppEventsHandlerLoadedData {
 declare class AppEventsHandler {
   readonly commandkit: CommandKit;
   /**
-   * @private
-   * @internal
-   */
+       * @private
+       * @internal
+       */
   private loadedEvents;
   /**
-   * Creates a new AppEventsHandler instance.
-   * @param commandkit - The CommandKit instance
-   */
+       * 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
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * Unregisters all event listeners and clears loaded events.
+       */
   unregisterAll(): void;
   /**
-   * Registers all loaded events with the Discord.js client and CommandKit event system.
-   */
+       * 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.
-   */
+       * Unregisters all client event listeners and cleans up loaded events.
+       */
   unregisterAllClientListeners(): void;
 }
 //#endregion
@@ -1069,16 +1070,16 @@ declare class AppEventsHandler {
  */
 interface IpcMessageCommand {
   /**
-   * The type of HMR event being communicated.
-   */
+       * The type of HMR event being communicated.
+       */
   event: HMREventType;
   /**
-   * The path associated with the HMR event.
-   */
+       * The path associated with the HMR event.
+       */
   path: string;
   /**
-   * An optional identifier for the HMR event, used for acknowledgment.
-   */
+       * An optional identifier for the HMR event, used for acknowledgment.
+       */
   id?: string;
 }
 /**
@@ -1086,22 +1087,22 @@ interface IpcMessageCommand {
  */
 interface CommandKitHMREvent {
   /**
-   * The type of HMR event.
-   */
+       * The type of HMR event.
+       */
   event: HMREventType;
   /**
-   * The path associated with the HMR event.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * Prevents the default action for the HMR event.
+       * This can be used to stop further processing of the event.
+       */
   preventDefault: () => void;
 }
 /**
@@ -1118,106 +1119,106 @@ declare abstract class RuntimePlugin<T extends PluginOptions = PluginOptions> ex
   readonly type = PluginType.Runtime;
   readonly preload: Set<string>;
   /**
-   * Called before commands are loaded
-   */
+       * Called before commands are loaded
+       */
   onBeforeCommandsLoad(ctx: CommandKitPluginRuntime): Promise<void>;
   /**
-   * Called after commands are loaded
-   */
+       * Called after commands are loaded
+       */
   onAfterCommandsLoad(ctx: CommandKitPluginRuntime): Promise<void>;
   /**
-   * Called before events are loaded
-   */
+       * Called before events are loaded
+       */
   onBeforeEventsLoad(ctx: CommandKitPluginRuntime): Promise<void>;
   /**
-   * Called after events are loaded
-   */
+       * Called after events are loaded
+       */
   onAfterEventsLoad(ctx: CommandKitPluginRuntime): Promise<void>;
   /**
-   * Called before the client logs in
-   */
+       * Called before the client logs in
+       */
   onBeforeClientLogin(ctx: CommandKitPluginRuntime): Promise<void>;
   /**
-   * Called after the client logs in
-   */
+       * Called after the client logs in
+       */
   onAfterClientLogin(ctx: CommandKitPluginRuntime): Promise<void>;
   /**
-   * Called before interaction is handled
-   * @param interaction The interaction
-   */
+       * 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
-   */
+       * 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
-   */
+       * 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
-   */
+       * 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
-   */
+       * 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
-   */
+       * 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
-   */
+       * 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
-   */
+       * 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
-   */
+       * 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
-   */
+       * 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
-   */
+       * 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.
-   */
+       * 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
-   */
+       * 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;
@@ -1236,28 +1237,28 @@ type MaybeFalsey<T> = T | false | null | undefined;
  */
 interface CommandKitEventDispatch {
   /**
-   * The name of the event.
-   */
+       * The name of the event.
+       */
   name: string;
   /**
-   * The arguments passed to the event.
-   */
+       * The arguments passed to the event.
+       */
   args: unknown[];
   /**
-   * The namespace of the event, if any.
-   */
+       * The namespace of the event, if any.
+       */
   namespace: string | null;
   /**
-   * If this event runs only once, it will be set to true.
-   */
+       * If this event runs only once, it will be set to true.
+       */
   once: boolean;
   /**
-   * The additional metadata associated with the event.
-   */
+       * The additional metadata associated with the event.
+       */
   metadata: ParsedEvent;
   /**
-   * Captures the owner of the event, preventing other plugins from handling it.
-   */
+       * Captures the owner of the event, preventing other plugins from handling it.
+       */
   accept(): void;
 }
 /**
@@ -1272,22 +1273,22 @@ type TemplateHandler = (args: string[]) => Promise<void> | void;
  */
 interface PluginTransformParameters {
   /**
-   * The code to be transformed.
-   */
+       * The code to be transformed.
+       */
   code: string;
   /**
-   * The filename of the code being transformed.
-   */
+       * The filename of the code being transformed.
+       */
   id: string;
 }
 interface TransformedResult {
   /**
-   * The transformed code.
-   */
+       * The transformed code.
+       */
   code?: string;
   /**
-   * The source map for the transformed code, if applicable.
-   */
+       * The source map for the transformed code, if applicable.
+       */
   map?: string | null;
 }
 /**
@@ -1295,14 +1296,14 @@ interface TransformedResult {
  */
 declare abstract class CompilerPlugin<T extends PluginOptions = PluginOptions> extends PluginCommon<T, CompilerPluginRuntime> {
   /**
-   * The type of the plugin, which is Compiler.
-   */
+       * The type of the plugin, which is Compiler.
+       */
   readonly type = PluginType.Compiler;
   /**
-   * Called when transformation is requested to this plugin
-   * @param params The parameters for the transformation
-   * @returns The transformed result
-   */
+       * 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>>;
 }
 /**
@@ -1318,9 +1319,9 @@ declare function isCompilerPlugin(plugin: unknown): plugin is CompilerPlugin;
  */
 type CommonDirectiveTransformerOptions = DirectiveTransformerOptions & {
   /**
-   * Whether the directive transformer is enabled.
-   * Defaults to true.
-   */
+       * Whether the directive transformer is enabled.
+       * Defaults to true.
+       */
   enabled?: boolean;
 };
 /**
@@ -1340,72 +1341,74 @@ declare abstract class CommonDirectiveTransformer extends CompilerPlugin<CommonD
 declare class CompilerPluginRuntime {
   #private;
   private readonly plugins;
+  readonly isDevMode: boolean;
   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[]);
+       * Creates a new instance of CompilerPluginRuntime.
+       * @param plugins An array of compiler plugins to be managed by this runtime.
+       * @param isDevMode Whether the build is in development mode.
+       */
+  constructor(plugins: CompilerPlugin[], isDevMode: boolean);
   /**
-   * Returns the plugins managed by this runtime.
-   */
+       * Returns the plugins managed by this runtime.
+       */
   getPlugins(): CompilerPlugin<PluginOptions>[];
   /**
-   * Checks if there are no plugins registered in this runtime.
-   */
+       * 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.
-   */
+       * 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;
   /**
-   * Unregister 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.
-   */
+       * Unregister 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.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * 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<{
@@ -1441,32 +1444,32 @@ declare enum PluginType {
 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.
-   */
+       * The type of the plugin, either Compiler or Runtime.
+       */
   abstract readonly type: PluginType;
   /**
-   * Unique identifier for the plugin instance.
-   */
+       * 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.
-   */
+       * The time when the plugin was loaded, in milliseconds since the Unix epoch.
+       */
   readonly loadedAt: number;
   /**
-   * The name of the plugin.
-   */
+       * The name of the plugin.
+       */
   abstract readonly name: string;
   /**
-   * Creates a new instance of the plugin.
-   */
+       * Creates a new instance of the plugin.
+       */
   constructor(options: T);
   /**
-   * Called when this plugin is activated
-   */
+       * Called when this plugin is activated
+       */
   activate(ctx: C): Promise<void>;
   /**
-   * Called when this plugin is deactivated
-   */
+       * Called when this plugin is deactivated
+       */
   deactivate(ctx: C): Promise<void>;
 }
 /**
@@ -1484,61 +1487,61 @@ declare class CommandKitPluginRuntime {
   readonly commandkit: CommandKit;
   private plugins;
   /**
-   * Creates a new instance of CommandKitPluginRuntime.
-   * @param commandkit The CommandKit instance associated with this runtime.
-   */
+       * 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.
-   */
+       * 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.
-   * @param pluginName The name of the plugin to check.
-   * @returns Boolean indicating whether the runtime is empty.
-   */
+       * Checks if there are no plugins registered in this runtime.
+       * @param pluginName The name of the plugin to check.
+       * @returns Boolean indicating whether the runtime is empty.
+       */
   getPlugin(pluginName: string): RuntimePlugin | null;
   /**
-   * Fetches the given plugin
-   * @param plugin The plugin to be fetched.
-   */
+       * Fetches the given plugin
+       * @param plugin The plugin to be fetched.
+       */
   get<T extends Constructable<any>>(plugin: T): InstanceType<T> | null;
   /**
-   * Pre-loads the specified entrypoints for the given plugin.
-   * @param plugin The plugin to pre-load.
-   */
+       * Pre-loads the specified entrypoints for the given plugin.
+       * @param plugin The plugin to pre-load.
+       */
   preload(plugin: RuntimePlugin): Promise<void>;
   /**
-   * Soft registers a plugin in the runtime.
-   * @param plugin The plugin to be registered.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * Unregisters all plugins from the runtime.
+       */
   unregisterAllPlugins(): Promise<void>;
   /**
-   * Signals the runtime to allow the current plugin take ownership of the execution context.
-   */
+       * 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.
-   */
+       * 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
@@ -1550,24 +1553,24 @@ declare class CommandKitPluginRuntime {
  */
 interface FlagProvider {
   /**
-   * Initialize the provider (e.g., establish connections, load initial config)
-   */
+       * Initialize the provider (e.g., establish connections, load initial config)
+       */
   initialize?(): MaybePromise<void>;
   /**
-   * Get the current value/configuration for a feature flag
-   * @param key - The feature flag key
-   * @param context - Optional context for flag evaluation
-   * @returns The flag configuration or null if not found
-   */
+       * Get the current value/configuration for a feature flag
+       * @param key - The feature flag key
+       * @param context - Optional context for flag evaluation
+       * @returns The flag configuration or null if not found
+       */
   getFlag(key: string, context?: any): MaybePromise<FlagConfiguration | null>;
   /**
-   * Check if a flag exists in the external system
-   * @param key - The feature flag key
-   */
+       * Check if a flag exists in the external system
+       * @param key - The feature flag key
+       */
   hasFlag(key: string): MaybePromise<boolean>;
   /**
-   * Cleanup resources when the provider is no longer needed
-   */
+       * Cleanup resources when the provider is no longer needed
+       */
   destroy?(): MaybePromise<void>;
 }
 /**
@@ -1575,20 +1578,20 @@ interface FlagProvider {
  */
 interface FlagConfiguration {
   /**
-   * Whether the flag is enabled/disabled at the provider level
-   */
+       * Whether the flag is enabled/disabled at the provider level
+       */
   enabled: boolean;
   /**
-   * Optional configuration data that can be used in the decide function
-   */
+       * Optional configuration data that can be used in the decide function
+       */
   config?: Record<string, any>;
   /**
-   * Optional percentage for gradual rollouts (0-100)
-   */
+       * Optional percentage for gradual rollouts (0-100)
+       */
   percentage?: number;
   /**
-   * Optional targeting rules or segments
-   */
+       * Optional targeting rules or segments
+       */
   targeting?: {
     segments?: string[];
     rules?: Array<{
@@ -1644,30 +1647,30 @@ type DecideFunction<E, R> = (data: {
  */
 interface FeatureFlagDefinition<R, Entity> {
   /**
-   * Unique key for the feature flag.
-   * Should be a string that identifies the flag.
-   */
+       * Unique key for the feature flag.
+       * Should be a string that identifies the flag.
+       */
   key: string;
   /**
-   * Optional description of the feature flag.
-   * This can be used for documentation or debugging purposes.
-   */
+       * Optional description of the feature flag.
+       * This can be used for documentation or debugging purposes.
+       */
   description?: string;
   /**
-   * Optional flag to enable integration with an external flag provider.
-   * If true, the flag will use the global flag provider to determine its state.
-   * Default: false
-   */
+       * Optional flag to enable integration with an external flag provider.
+       * If true, the flag will use the global flag provider to determine its state.
+       * Default: false
+       */
   identify?: IdentifyFunction<Entity>;
   /**
-   * Function to decide the outcome of the feature flag.
-   * This function receives the identified entities and should return the result of the decision.
-   */
+       * Function to decide the outcome of the feature flag.
+       * This function receives the identified entities and should return the result of the decision.
+       */
   decide: DecideFunction<Entity, R>;
   /**
-   * Whether to disable analytics tracking for this flag.
-   * Default: false
-   */
+       * Whether to disable analytics tracking for this flag.
+       * Default: false
+       */
   disableAnalytics?: boolean;
 }
 /**
@@ -1675,49 +1678,49 @@ interface FeatureFlagDefinition<R, Entity> {
  */
 interface CommandFlagContext {
   /**
-   * The Discord client instance.
-   * This is the main entry point for interacting with the Discord API.
-   */
+       * The Discord client instance.
+       * This is the main entry point for interacting with the Discord API.
+       */
   client: Client<true>;
   /**
-   * The CommandKit instance, which provides access to the command framework.
-   * This includes commands, events, and other features of CommandKit.
-   */
+       * The CommandKit instance, which provides access to the command framework.
+       * This includes commands, events, and other features of CommandKit.
+       */
   commandkit: CommandKit;
   /**
-   * The command context, which includes information about the command being executed.
-   * This can include the interaction, message, guild, channel, and the loaded command.
-   */
+       * The command context, which includes information about the command being executed.
+       * This can include the interaction, message, guild, channel, and the loaded command.
+       */
   command: {
     /**
-     * The interaction object if the command was invoked via an interaction.
-     * This can be a ChatInputCommandInteraction, AutocompleteInteraction, or ContextMenuCommandInteraction.
-     */
+             * The interaction object if the command was invoked via an interaction.
+             * This can be a ChatInputCommandInteraction, AutocompleteInteraction, or ContextMenuCommandInteraction.
+             */
     interaction?: ChatInputCommandInteraction | AutocompleteInteraction | ContextMenuCommandInteraction;
     /**
-     * The message object if the command was invoked via a message.
-     */
+             * The message object if the command was invoked via a message.
+             */
     message?: Message;
     /**
-     * The guild where the command was invoked, if applicable.
-     * This will be null for commands invoked in DMs.
-     */
+             * The guild where the command was invoked, if applicable.
+             * This will be null for commands invoked in DMs.
+             */
     guild: Guild | null;
     /**
-     * The channel where the command was invoked.
-     * This can be a text channel, DM channel, or any other type of text-based channel.
-     */
+             * The channel where the command was invoked.
+             * This can be a text channel, DM channel, or any other type of text-based channel.
+             */
     channel: TextBasedChannel | null;
     /**
-     * The loaded command instance that is being executed.
-     * This contains the command's metadata and logic.
-     */
+             * The loaded command instance that is being executed.
+             * This contains the command's metadata and logic.
+             */
     command: LoadedCommand;
   };
   /**
-   * The event context is null for command flags, as they are not tied to a specific event.
-   * This is used to differentiate between command and event flags.
-   */
+       * The event context is null for command flags, as they are not tied to a specific event.
+       * This is used to differentiate between command and event flags.
+       */
   event: null;
 }
 /**
@@ -1725,53 +1728,53 @@ interface CommandFlagContext {
  */
 interface EventFlagContext {
   /**
-   * The Discord client instance.
-   * This is the main entry point for interacting with the Discord API.
-   */
+       * The Discord client instance.
+       * This is the main entry point for interacting with the Discord API.
+       */
   client: Client<true>;
   /**
-   * The CommandKit instance, which provides access to the command framework.
-   * This includes commands, events, and other features of CommandKit.
-   */
+       * The CommandKit instance, which provides access to the command framework.
+       * This includes commands, events, and other features of CommandKit.
+       */
   commandkit: CommandKit;
   /**
-   * The event context, which includes information about the event being processed.
-   * This can include the parsed event data, the event name, and the namespace if applicable.
-   */
+       * The event context, which includes information about the event being processed.
+       * This can include the parsed event data, the event name, and the namespace if applicable.
+       */
   event: {
     /**
-     * The parsed event data, which contains the raw data from the event.
-     * This can include information like user IDs, channel IDs, and other relevant data.
-     */
+             * The parsed event data, which contains the raw data from the event.
+             * This can include information like user IDs, channel IDs, and other relevant data.
+             */
     data: ParsedEvent;
     /**
-     * The name of the event being processed.
-     * This is the string identifier for the event, such as 'messageCreate' or 'guildMemberAdd'.
-     */
+             * The name of the event being processed.
+             * This is the string identifier for the event, such as 'messageCreate' or 'guildMemberAdd'.
+             */
     event: string;
     /**
-     * The namespace of the event, if applicable.
-     * This can be used to group related events or commands together.
-     * It is null if the event does not belong to a specific namespace.
-     */
+             * The namespace of the event, if applicable.
+             * This can be used to group related events or commands together.
+             * It is null if the event does not belong to a specific namespace.
+             */
     namespace: string | null;
     /**
-     * The arguments passed to the event handler.
-     * This is an array of arguments that were passed when the event was triggered.
-     * It can be used to access specific data related to the event.
-     */
+             * The arguments passed to the event handler.
+             * This is an array of arguments that were passed when the event was triggered.
+             * It can be used to access specific data related to the event.
+             */
     arguments: any[];
     /**
-     * A function to retrieve the arguments for a specific event type.
-     * This allows for type-safe access to the arguments based on the event name.
-     * @param event - The name of the event to retrieve arguments for.
-     */
+             * A function to retrieve the arguments for a specific event type.
+             * This allows for type-safe access to the arguments based on the event name.
+             * @param event - The name of the event to retrieve arguments for.
+             */
     argumentsAs<E extends keyof ClientEvents>(event: E): ClientEvents[E];
   };
   /**
-   * The command context is null for event flags, as they are not tied to a specific command.
-   * This is used to differentiate between command and event flags.
-   */
+       * The command context is null for event flags, as they are not tied to a specific command.
+       * This is used to differentiate between command and event flags.
+       */
   command: null;
 }
 /**
@@ -1791,25 +1794,25 @@ type CustomEvaluationFunction<E> = () => MaybePromise<E>;
  */
 type CustomEvaluationContext<E> = {
   /**
-   * Optional function to identify the entities for evaluation.
-   * This can be a function that returns the entities based on the current context.
-   */
+       * Optional function to identify the entities for evaluation.
+       * This can be a function that returns the entities based on the current context.
+       */
   identify: E | CustomEvaluationFunction<E>;
 };
 interface FlagRunner<E, R> {
   /**
-   * Execute the feature flag evaluation with the provided entities.
-   * This method will run the identify and decide functions to determine the flag's outcome.
-   * @param res - Optional entities to use for evaluation. If not provided, it will call the identify function.
-   * @returns A promise that resolves to the result of the feature flag evaluation.
-   */
+       * Execute the feature flag evaluation with the provided entities.
+       * This method will run the identify and decide functions to determine the flag's outcome.
+       * @param res - Optional entities to use for evaluation. If not provided, it will call the identify function.
+       * @returns A promise that resolves to the result of the feature flag evaluation.
+       */
   (): Promise<R>;
   /**
-   * Run the feature flag evaluation with a custom context.
-   * This allows for more flexible evaluation based on custom logic or external data.
-   * @param context - The custom evaluation context containing the identify function or object.
-   * @returns A promise that resolves to the result of the feature flag evaluation.
-   */
+       * Run the feature flag evaluation with a custom context.
+       * This allows for more flexible evaluation based on custom logic or external data.
+       * @param context - The custom evaluation context containing the identify function or object.
+       * @returns A promise that resolves to the result of the feature flag evaluation.
+       */
   run(context: CustomEvaluationContext<E>): Promise<R>;
 }
 /**
@@ -1819,16 +1822,16 @@ declare class FeatureFlag<R, T> {
   readonly options: FeatureFlagDefinition<R, T>;
   private commandkit;
   /**
-   * Create a new feature flag.
-   * @param options - The options for the feature flag.
-   */
+       * Create a new feature flag.
+       * @param options - The options for the feature flag.
+       */
   constructor(options: FeatureFlagDefinition<R, T>);
   private getContext;
   /**
-   * Execute the feature flag evaluation.
-   * @param res - Optional entities to use for evaluation. If not provided, it will call the identify function.
-   * @returns A promise that resolves to the result of the feature flag evaluation.
-   */
+       * Execute the feature flag evaluation.
+       * @param res - Optional entities to use for evaluation. If not provided, it will call the identify function.
+       * @returns A promise that resolves to the result of the feature flag evaluation.
+       */
   execute(res?: T): Promise<R>;
 }
 /**
@@ -1848,114 +1851,114 @@ declare class FlagStore extends Collection<string, FeatureFlag<any, any>> {}
 //#region src/config/types.d.ts
 interface CommandKitCompilerOptions {
   /**
-   * The macro compiler options to use with CommandKit.
-   */
+       * The macro compiler options to use with CommandKit.
+       */
   macro?: {
     /**
-     * Whether to enable macro function compilation in development mode.
-     * @default false
-     */
+             * Whether to enable macro function compilation in development mode.
+             * @default false
+             */
     development?: boolean;
   };
   /**
-   * The tsdown compiler options to use with CommandKit.
-   * **DO NOT USE THIS UNLESS YOU KNOW WHAT YOU ARE DOING** as it alters the behavior of the build process.
-   */
-  tsdown?: Partial<Options>;
+       * The tsdown compiler options to use with CommandKit.
+       * **DO NOT USE THIS UNLESS YOU KNOW WHAT YOU ARE DOING** as it alters the behavior of the build process.
+       */
+  tsdown?: Partial<InlineConfig>;
   /**
-   * Disables chunking of the output (production only, development never chunks).
-   * @default false
-   */
+       * Disables chunking of the output (production only, development never chunks).
+       * @default false
+       */
   disableChunking?: boolean;
 }
 interface CommandKitConfig {
   /**
-   * The plugins to use with CommandKit.
-   * Can be a single plugin, an array of plugins, or a nested array of plugins.
-   */
+       * The plugins to use with CommandKit.
+       * Can be a single plugin, an array of plugins, or a nested array of plugins.
+       */
   plugins?: MaybeArray<CommandKitPlugin>[] | Array<CommandKitPlugin>;
   /**
-   * The rolldown plugins to use with CommandKit.
-   */
+       * The rolldown plugins to use with CommandKit.
+       */
   rolldownPlugins?: any[];
   /**
-   * The list of additional entrypoints to compile. Eg, `dir` or `dir/index.ts` or `dir/*.ts`, etc.
-   * Similarly, negative patterns can be used to exclude files. Eg, `!dir/index.ts` or `!dir/*.ts`, etc.
-   */
+       * The list of additional entrypoints to compile. Eg, `dir` or `dir/index.ts` or `dir/*.ts`, etc.
+       * Similarly, negative patterns can be used to exclude files. Eg, `!dir/index.ts` or `!dir/*.ts`, etc.
+       */
   entrypoints?: string[];
   /**
-   * The compiler options to use with CommandKit.
-   */
+       * The compiler options to use with CommandKit.
+       */
   compilerOptions?: CommandKitCompilerOptions;
   /**
-   * The typescript configuration to use with CommandKit.
-   */
+       * The typescript configuration to use with CommandKit.
+       */
   typescript?: {
     /**
-     * Whether to ignore type checking during builds.
-     */
+             * Whether to ignore type checking during builds.
+             */
     ignoreBuildErrors?: boolean;
   };
   /**
-   * Whether to generate static command handler data in production builds.
-   */
+       * Whether to generate static command handler data in production builds.
+       */
   static?: boolean;
   /**
-   * Statically define the environment variables to use.
-   */
+       * Statically define the environment variables to use.
+       */
   env?: Record<string, string>;
   /**
-   * The custom build directory name to use.
-   * @default `dist`
-   */
+       * The custom build directory name to use.
+       * @default `dist`
+       */
   distDir?: string;
   /**
-   * The anti-crash script configuration.
-   */
+       * The anti-crash script configuration.
+       */
   antiCrashScript?: {
     /**
-     * Whether to enable the anti-crash script in development mode.
-     * @default true
-     */
+             * Whether to enable the anti-crash script in development mode.
+             * @default true
+             */
     development?: boolean;
     /**
-     * Whether to enable the anti-crash script in production mode. Usually, you should use other means to handle errors.
-     * @default false
-     */
+             * Whether to enable the anti-crash script in production mode. Usually, you should use other means to handle errors.
+             * @default false
+             */
     production?: boolean;
   };
   /**
-   * Whether or not to enable the source map generation.
-   */
+       * Whether or not to enable the source map generation.
+       */
   sourceMap?: {
     /**
-     * Whether to enable source map generation in development mode.
-     */
+             * Whether to enable source map generation in development mode.
+             */
     development?: boolean;
     /**
-     * Whether to enable source map generation in production mode.
-     */
+             * Whether to enable source map generation in production mode.
+             */
     production?: boolean;
   };
   /**
-   * Whether or not to enable the typed commands.
-   * @default true
-   */
+       * Whether or not to enable the typed commands.
+       * @default true
+       */
   typedCommands?: boolean;
   /**
-   * Whether or not to disable the prefix commands.
-   * @default false
-   */
+       * Whether or not to disable the prefix commands.
+       * @default false
+       */
   disablePrefixCommands?: boolean;
   /**
-   * Whether or not to disable the built-in permissions middleware. This only affects `botPermissions` and `userPermissions` in the command metadata.
-   * @default false
-   */
+       * Whether or not to disable the built-in permissions middleware. This only affects `botPermissions` and `userPermissions` in the command metadata.
+       * @default false
+       */
   disablePermissionsMiddleware?: boolean;
   /**
-   * Whether or not to show a warning when a prefix command is not found. This only affects development mode.
-   * @default true
-   */
+       * Whether or not to show a warning when a prefix command is not found. This only affects development mode.
+       * @default true
+       */
   showUnknownPrefixCommandsWarning?: boolean;
 }
 //#endregion
@@ -1987,16 +1990,16 @@ type ResolvedCommandKitConfig = DeepRequired<CommandKitConfig, 'compilerOptions'
  */
 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
-   */
+       * 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.
-   */
+       * 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[] | RegExp>;
 }
 /**
@@ -2037,133 +2040,133 @@ declare function onApplicationBootstrap<F extends BootstrapFunction>(fn: F): voi
 declare class CommandKit extends EventEmitter {
   #private;
   /**
-   * The event interceptor to quickly register temporary event listeners
-   */
+       * The event interceptor to quickly register temporary event listeners
+       */
   eventInterceptor: EventInterceptor;
   /**
-   * The static createElement function to create jsx elements
-   */
+       * The static createElement function to create jsx elements
+       */
   static readonly createElement: typeof createElement;
   /**
-   * The static Fragment component to create jsx fragments
-   */
+       * The static Fragment component to create jsx fragments
+       */
   static readonly Fragment: typeof Fragment;
   /**
-   * The configuration for the CommandKit instance.
-   */
+       * The configuration for the CommandKit instance.
+       */
   readonly appConfig: CommandKitConfiguration;
   /**
-   * The configuration for the CommandKit environment.
-   */
+       * The configuration for the CommandKit environment.
+       */
   config: ResolvedCommandKitConfig;
   /**
-   * A key-value store for storing arbitrary data.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * The command router for the CommandKit instance.
+       */
   commandsRouter: CommandsRouter;
   /**
-   * The events router for the CommandKit instance.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * The plugins runtime for the CommandKit instance.
+       */
   plugins: CommandKitPluginRuntime;
   /**
-   * The events channel for the CommandKit instance. This can be used to emit custom events.
-   */
+       * 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.
-   */
+       * The analytics engine for the CommandKit instance.
+       * This is responsible for tracking events and user interactions.
+       */
   analytics: AnalyticsEngine;
   /**
-   * The static instance of CommandKit.
-   */
+       * The static instance of CommandKit.
+       */
   static instance: CommandKit | undefined;
   /**
-   * Create a new command and event handler with CommandKit.
-   * @param options - The default CommandKit configuration.
-   */
+       * Create a new command and event handler with CommandKit.
+       * @param options - The default CommandKit configuration.
+       */
   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.
-   */
+       * 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.
-   */
+       * Loads all the plugins.
+       */
   loadPlugins(): Promise<void>;
   /**
-   * Whether or not the commandkit application has started.
-   */
+       * Whether or not the commandkit application has started.
+       */
   get started(): boolean;
   /**
-   * Sets the prefix resolver for the command handler.
-   * @param resolver The resolver function.
-   */
+       * Sets the prefix resolver for the command handler.
+       * @param resolver The resolver function.
+       */
   setPrefixResolver(resolver: (message: Message) => Awaitable<string | string[] | RegExp>): this;
   /**
-   * Sets the default locale for the command handler.
-   * @param locale The default locale.
-   */
+       * 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 the client attached to this CommandKit instance.
+       */
   get client(): Client;
   /**
-   * Sets the client attached to this CommandKit instance.
-   * @param client The client to set.
-   */
+       * Sets the client attached to this CommandKit instance.
+       * @param client The client to set.
+       */
   setClient(client: Client): this;
   /**
-   * Updates application commands with the latest from "commandsPath".
-   */
+       * Updates application commands with the latest from "commandsPath".
+       */
   reloadCommands(): Promise<void>;
   /**
-   * Updates application events with the latest from "eventsPath".
-   */
+       * Updates application events with the latest from "eventsPath".
+       */
   reloadEvents(): Promise<void>;
   /**
-   * Increment the client listeners count.
-   */
+       * Increment the client listeners count.
+       */
   incrementClientListenersCount(): void;
   /**
-   * Decrement the client listeners count.
-   */
+       * Decrement the client listeners count.
+       */
   decrementClientListenersCount(): void;
   /**
-   * Path to the app directory. Returns `null` if not found.
-   * The lookup order is:
-   * - `./app`
-   * - `./src/app`
-   */
+       * Path to the app directory. Returns `null` if not found.
+       * The lookup order is:
+       * - `./app`
+       * - `./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
-   */
+       * 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;
 }
 /**
@@ -2190,19 +2193,19 @@ type IdentifyEvent = Record<string, any>;
  */
 interface AnalyticsProvider {
   /**
-   * The name of the analytics provider.
-   * This is used for logging and identification purposes.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * 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
@@ -2222,49 +2225,49 @@ declare class AnalyticsEngine {
   #private;
   readonly commandkit: CommandKit;
   /**
-   * Creates an instance of the AnalyticsEngine.
-   * @param commandkit The CommandKit instance.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * 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.
-   */
+       * 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
-export { AnalyticsEngine, AnalyticsEvent, AnalyticsProvider, AnyCommandExecute, AppCommand, AppCommandHandler, AppCommandNative, AppCommandRunner, AppEventsHandler, AppEventsHandlerLoadedData, AsyncFunction, AutocompleteCommand, AutocompleteCommandContext, AutocompleteCommandMiddlewareContext, BootstrapFunction, ChatInputCommand, ChatInputCommandContext, CommandBuilderLike, CommandContext, CommandContextOptions, CommandData, CommandDataSchema, CommandDataSchemaKey, CommandDataSchemaValue, CommandExecutionMode, CommandFlagContext, CommandKit, CommandKitCompilerOptions, CommandKitConfig, CommandKitConfiguration, CommandKitEnvironment, CommandKitEnvironmentInternalData, CommandKitEnvironmentType, CommandKitEventDispatch, CommandKitEventsChannel, CommandKitHMREvent, CommandKitOptions, CommandKitPlugin, CommandKitPluginRuntime, CommandMetadata, CommandMetadataFunction, CommandRegistrar, CommandTypeData, CommonDirectiveTransformer, CommonDirectiveTransformerOptions, CommonPluginRuntime, CompilerPlugin, CompilerPluginRuntime, Context, ContextParameters, CustomAppCommandProps, CustomEvaluationContext, CustomEvaluationFunction, DecideFunction, DeepPartial, DeepRequired, EvaluationContext, EventFlagContext, EventHandler, 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, ResolvedCommandKitConfig, RunCommand, RunCommandOptions, RuntimePlugin, SlashCommandMiddlewareContext, TemplateHandler, TransformedResult, UserContextMenuCommand, UserContextMenuCommandContext, UserContextMenuCommandMiddlewareContext, after, cancelAfter, commandkit, exitContext, flag, getCommandKit, getContext, isCommandWorkerContext, isCompilerPlugin, isPlugin, isRuntimePlugin, makeContextAwareFunction, mergeDeep, onApplicationBootstrap, onBootstrap, provideContext, registerDevHooks, setFlagProvider, useEnvironment, useStore };
-//# sourceMappingURL=analytics-engine-NOInIjv8.d.ts.map
+export { isRuntimePlugin as $, MessageCommand as $t, flag as A, makeContextAwareFunction as At, CommonPluginRuntime as B, PreRegisterCommandsEvent as Bt, EvaluationContext as C, RunCommandOptions as Ct, FlagRunner as D, getCommandKit as Dt, FeatureFlagDefinition as E, exitContext as Et, CommandKitPluginRuntime as F, CommandKitEnvironmentInternalData as Ft, PluginTransformParameters as G, ChatInputCommand as Gt, CommonDirectiveTransformer as H, AutocompleteCommand as Ht, PluginCommon as I, CommandKitEnvironmentType as It, CommandKitEventDispatch as J, CommandExecutionMode as Jt, TransformedResult as K, ChatInputCommandContext as Kt, PluginOptions as L, after as Lt, FlagConfiguration as M, useEnvironment as Mt, FlagProvider as N, useStore as Nt, IdentifyFunction as O, getContext as Ot, JsonFlagProvider as P, CommandKitEnvironment as Pt, RuntimePlugin as Q, InteractionCommandMiddlewareContext as Qt, PluginType as R, cancelAfter as Rt, DecideFunction as S, AppCommandRunner as St, FeatureFlag as T, GenericFunction as Tt, CommonDirectiveTransformerOptions as U, AutocompleteCommandContext as Ut, CompilerPluginRuntime as V, AnyCommandExecute as Vt, CompilerPlugin as W, AutocompleteCommandMiddlewareContext as Wt, MaybeFalsey as X, ContextParameters as Xt, CommandKitPlugin as Y, Context as Yt, TemplateHandler as Z, InteractionCommandContext as Zt, CommandKitConfig as _, CustomAppCommandProps as _t, IdentifyEvent as a, MiddlewareContext as an, EventListener as at, CustomEvaluationContext as b, ResolvableCommand as bt, CommandKitConfiguration as c, UserContextMenuCommand as cn, ListenerFunction as ct, onBootstrap as d, CommandContext as dn, AppCommandNative as dt, MessageCommandContext as en, CommandKitHMREvent as et, DeepPartial as f, CommandData as fn, CommandBuilderLike as ft, CommandKitCompilerOptions as g, EventHandler as gn, CommandTypeData as gt, mergeDeep as h, CommandMetadataFunction as hn, CommandDataSchemaValue as ht, AnalyticsProvider as i, MessageContextMenuCommandMiddlewareContext as in, AppEventsHandlerLoadedData as it, setFlagProvider as j, provideContext as jt, MaybePromise as k, isCommandWorkerContext as kt, commandkit as l, UserContextMenuCommandContext as ln, AppCommand as lt, ResolvedCommandKitConfig as m, CommandMetadata as mn, CommandDataSchemaKey as mt, FilterFunction as n, MessageContextMenuCommand as nn, registerDevHooks as nt, BootstrapFunction as o, MiddlewareContextArgs as on, LoadedEvent as ot, DeepRequired as p, CommandKitOptions as pn, CommandDataSchema as pt, isCompilerPlugin as q, CommandContextOptions as qt, AnalyticsEvent as r, MessageContextMenuCommandContext as rn, AppEventsHandler as rt, CommandKit as s, SlashCommandMiddlewareContext as sn, CommandKitEventsChannel as st, AnalyticsEngine as t, MessageCommandMiddlewareContext as tn, IpcMessageCommand as tt, onApplicationBootstrap as u, UserContextMenuCommandMiddlewareContext as un, AppCommandHandler as ut, FlagStore as v, LoadedCommand as vt, EventFlagContext as w, AsyncFunction as wt, CustomEvaluationFunction as x, RunCommand as xt, CommandFlagContext as y, PreparedAppCommandExecution as yt, isPlugin as z, CommandRegistrar as zt };
+//# sourceMappingURL=analytics-engine-WQhXmx3H.d.ts.map