commandkit 0.1.11-dev.20250306152436 → 0.1.11-dev.20250308073818

package/dist/index.d.ts

@@ -1007,131 +1007,165 @@ declare class MiddlewareContext<T extends CommandExecutionMode = CommandExecutio
     cancel(): void;
 }
 
+/**
+ * Represents a command file info parsed from the file system.
+ * It does not contain any command specific data, as that's loaded later by the command handler.
+ */
 interface ParsedCommand {
     /**
-     * The unique identifier of this command.
+     * The unique identifier of the command. This is used to distinguish between commands that may have the same name.
      */
     id: string;
     /**
-     * The file name without the extension.
+     * The file name of the command.
      */
     name: string;
     /**
-     * The full path to the command file.
-     * This can be null for directories that function as command groups but have no index file.
+     * The absolute path to the command file.
      */
-    path: string | null;
+    path: string;
     /**
-     * The category of the command.
+     * The relative path from the cwd to the command file.
      */
-    category: string | null;
+    relativePath: string;
     /**
-     * The subcommands of this command parsed from `(category)` format, but omitting the brackets.
+     * The category of this command. This will be the parent directory segment that matches /(category)/ in the path.
+     * When there are multiple segments, they are combined with a colon.
+     * Example: `/commands/(games)/tictactoe.js` -> category is `games`
+     * Example: `/commands/(games)/(fun)/tictactoe.js` -> category is `games:fun`
+     * Category is `null` if the parent directory segment does not match `/(\w+)/`.
      */
-    subcommands: string[];
+    category: string | null;
     /**
-     * The middlewares of this command.
+     * Array of ids referencing the associated middleware for this command.
      */
     middlewares: string[];
+    /**
+     * Array of ids referencing the associated subcommands for this command.
+     */
+    subcommands: string[];
 }
-interface ParsedSubCommand {
+/**
+ * Represents a middleware file info parsed from the file system.
+ */
+interface ParsedMiddleware {
     /**
-     * The unique identifier of this subcommand.
+     * The unique identifier of the middleware. This is used to distinguish between middlewares that may have the same name.
      */
     id: string;
     /**
-     * The file name without the extension.
+     * The file name of the middleware.
      */
     name: string;
     /**
-     * The full path to the subcommand file.
+     * The absolute path to the middleware file.
      */
     path: string;
     /**
-     * The category of the subcommand parsed from `(category)` format, but omitting the brackets.
-     */
-    category: string | null;
-    /**
-     * The subcommand group name for this subcommand.
+     * The relative path from the cwd to the middleware file.
      */
-    group: string | null;
+    relativePath: string;
     /**
-     * The middlewares of this subcommand.
+     * The category of this middleware. This will be the parent directory segment that matches /(category)/ in the path.
      */
-    middlewares: string[];
+    category: string | null;
 }
-interface ParsedMiddleware {
+/**
+ * Represents a subcommand file info parsed from the file system.
+ */
+interface ParsedSubCommand {
     /**
-     * The file name without the extension.
+     * The unique identifier of the subcommand. This is used to distinguish between subcommands that may have the same name.
      */
-    name: string;
+    id: string;
     /**
-     * The unique identifier of this middleware.
+     * The name of the subcommand.
      */
-    id: string;
+    name: string;
     /**
-     * The full path to this middleware file.
+     * The group name of the subcommand. This is used to group subcommands together in the Discord UI.
      */
-    path: string;
+    group: string | null;
     /**
-     * The category of this middleware.
+     * The category of this subcommand. This will be the parent directory segment that matches /(category)/ in the path.
      */
     category: string | null;
-}
-interface CommandsTree {
     /**
-     * The record of commands mapped by their unique identifiers.
+     * The absolute path to the subcommand file.
      */
-    commands: Record<string, ParsedCommand>;
+    path: string;
     /**
-     * The record of subcommands mapped by their unique identifiers.
+     * The relative path from the cwd to the subcommand file.
      */
-    subcommands: Record<string, ParsedSubCommand>;
+    relativePath: string;
     /**
-     * The record of middlewares mapped by their unique identifiers.
+     * Array of ids referencing the associated middleware for this subcommand.
      */
+    middlewares: string[];
+}
+/**
+ * Represents a JSON compatible object that contains all the parsed commands, middlewares, and subcommands.
+ */
+interface CommandTree {
+    commands: Record<string, ParsedCommand>;
     middlewares: Record<string, ParsedMiddleware>;
+    subcommands: Record<string, ParsedSubCommand>;
 }
-interface ParsedCommandsData {
-    /**
-     * The collection of parsed commands.
-     */
+/**
+ * Represents the scanned and parsed command files.
+ */
+interface ParsedCommandData {
     commands: Collection<string, ParsedCommand>;
-    /**
-     * The collection of parsed subcommands.
-     */
-    subcommands: Collection<string, ParsedSubCommand>;
-    /**
-     * The collection of parsed middlewares.
-     */
     middlewares: Collection<string, ParsedMiddleware>;
+    subcommands: Collection<string, ParsedSubCommand>;
 }
 interface CommandsRouterOptions {
     /**
-     * The entrypoint directory to scan for commands.
+     * The path to the directory containing the command files.
      */
     entrypoint: string;
 }
 declare class CommandsRouter {
-    private readonly options;
+    private options;
     private commands;
-    private subcommands;
     private middlewares;
+    private subcommands;
     constructor(options: CommandsRouterOptions);
-    get entrypoint(): string;
     isValidPath(): boolean;
-    getData(): ParsedCommandsData;
-    toJSON(): CommandsTree;
+    get entrypoint(): string;
     clear(): void;
-    reload(): Promise<CommandsTree>;
-    scan(): Promise<CommandsTree>;
-    private scanDirectory;
-    private processMiddlewares;
+    reload(): Promise<CommandTree>;
+    visualize(): string;
+    getData(): ParsedCommandData;
+    toJSON(): CommandTree;
+    scan(): Promise<CommandTree>;
+    private scanDeep;
+    /**
+     * Gets path segments between two paths, excluding the start and end paths
+     * Used to check if all directories between a path and the entrypoint are category directories
+     */
+    private getPathSegmentsBetween;
+    private processMiddleware;
+    private processSubcommand;
     private processCommand;
-    private processCommandDirectory;
-    private processSubCommand;
-    private parseNameAndCategory;
-    private findAssociatedMiddlewares;
+    private extractDirOmitCategory;
+    /**
+     * Gets the appropriate file name, handling index files specially
+     * For index files, it returns the parent directory name (excluding category markers)
+     */
+    private getAppropriateFileName;
+    /**
+     * Extract the clean directory name, removing any category markers
+     */
+    private getDirectoryName;
+    private isCategoryDirectory;
+    private applyMiddlewareToCommands;
+    private applySubcommandToCommands;
+    private extractCategory;
+    private getRelativePath;
+    private isMiddleware;
+    private shouldIgnore;
+    private extractName;
 }
 
 /**
@@ -1308,6 +1342,154 @@ declare class AppCommandHandler {
     applyLocalizations(command: CommandBuilderLike): Promise<discord_js.RESTPostAPIContextMenuApplicationCommandsJSONBody | CommandBuilderLike>;
 }
 
+declare class MemoryCache extends CacheProvider {
+    #private;
+    get<T>(key: string): Promise<CacheEntry<T> | undefined>;
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    expire(key: string, ttl: number): Promise<void>;
+}
+
+/**
+ * Context for managing cache operations within an async scope
+ */
+interface CacheContext {
+    params: {
+        /** Custom name for the cache entry */
+        name?: string;
+        /** Time-to-live in milliseconds */
+        ttl?: number;
+    };
+}
+/**
+ * Represents an async function that can be cached
+ * @template R - Array of argument types
+ * @template T - Return type
+ */
+type AsyncFunction<R extends any[] = any[], T = any> = (...args: R) => Promise<T>;
+/**
+ * Configuration options for cache behavior
+ */
+interface CacheMetadata {
+    /** Time-to-live duration in milliseconds or as a string (e.g., '1h', '5m') */
+    ttl?: number | string;
+    /** Custom name for the cache entry */
+    name?: string;
+}
+/**
+ * Internal cache implementation
+ * @internal
+ * @private
+ * This is used directly by the compiler if the function is annotated with `"use cache"` directive.
+ * @example
+ * ```ts
+ * async function myCachedFunction() {
+ *   "use cache";
+ *   // can use cacheTag() and cacheLife() here to customize cache behavior
+ *   return await db.query('SELECT * FROM users');
+ * }
+ * ```
+ */
+declare function useCache<R extends any[], F extends AsyncFunction<R>>(fn: F, id?: string, params?: CacheMetadata): F;
+/**
+ * Wraps an async function with caching capability
+ * @template R - Array of argument types
+ * @template F - Type of the async function
+ * @param fn - The async function to cache
+ * @param params - Optional cache configuration
+ * @returns The wrapped function with caching behavior
+ * @example
+ * ```ts
+ * const cachedFetch = cache(async (id: string) => {
+ *   return await db.findOne(id);
+ * }, { ttl: '1h' });
+ * ```
+ */
+declare function cache<R extends any[], F extends AsyncFunction<R>>(fn: F, params?: CacheMetadata): F;
+/**
+ * Sets a custom identifier for the current cache operation
+ * @param tag - The custom cache tag
+ * @throws {Error} When called outside a cached function or without a tag
+ * @example
+ * ```ts
+ * const fetchUser = cache(async (id: string) => {
+ *   cacheTag(`user:${id}`);
+ *   return await db.users.findOne(id);
+ * });
+ * ```
+ */
+declare function cacheTag(tag: string): void;
+/**
+ * Sets the TTL for the current cache operation
+ * @param ttl - Time-to-live in milliseconds or as a string (e.g., '1h', '5m')
+ * @throws {Error} When called outside a cached function or with invalid TTL
+ * @example
+ * ```ts
+ * const fetchData = cache(async () => {
+ *   cacheLife('30m');
+ *   return await expensiveOperation();
+ * });
+ * ```
+ */
+declare function cacheLife(ttl: number | string): void;
+/**
+ * Removes a cached value by its tag
+ * @param tag - The cache tag to invalidate
+ * @throws {Error} When the cache key is not found
+ * @example
+ * ```ts
+ * await invalidate('user:123');
+ * ```
+ */
+declare function invalidate(tag: string): Promise<void>;
+/**
+ * Forces a refresh of cached data by its tag (on-demand revalidation)
+ * @template T - Type of the cached value
+ * @param tag - The cache tag to revalidate
+ * @param args - Arguments to pass to the cached function
+ * @returns Fresh data from the cached function
+ * @throws {Error} When the cache key or function is not found
+ * @example
+ * ```ts
+ * const freshData = await revalidate('user:123');
+ * ```
+ */
+declare function revalidate<T = unknown>(tag: string, ...args: any[]): Promise<T>;
+/**
+ * Checks if a function is wrapped with cache functionality
+ * @param fn - Function to check
+ * @returns True if the function is cached
+ * @example
+ * ```ts
+ * if (isCachedFunction(myFunction)) {
+ *   console.log('Function is cached');
+ * }
+ * ```
+ */
+declare function isCachedFunction(fn: GenericFunction): boolean;
+
+type ListenerFunction = GenericFunction | AsyncFunction;
+declare class CommandKitEventsChannel {
+    readonly commandkit: CommandKit;
+    private emitter;
+    constructor(commandkit: CommandKit);
+    to(namespace: string): {
+        on: (event: string, listener: ListenerFunction) => void;
+        off: (event: string, listener: ListenerFunction) => void;
+        once: (event: string, listener: ListenerFunction) => void;
+        emit: (event: string, ...args: any[]) => boolean;
+        removeAllListeners: (event: string) => void;
+    };
+    on(namespace: string, event: string, listener: ListenerFunction): void;
+    off(namespace: string, event: string, listener: ListenerFunction): void;
+    once(namespace: string, event: string, listener: ListenerFunction): void;
+    emit(namespace: string, event: string, ...args: any[]): boolean;
+    removeAllListeners(namespace: string): void;
+    removeAllListeners(namespace: string, event: string): void;
+}
+
 declare class AppEventsHandler {
     readonly commandkit: CommandKit;
     private loadedEvents;
@@ -1471,6 +1653,7 @@ declare class DefaultLocalizationStrategy implements LocalizationStrategy {
     private translations;
     constructor(commandkit: CommandKit);
     locateTranslation(scope: string, locale: Locale): Promise<Translation | null>;
+    private generateLocaleTypes;
     getTranslationStrict(scope: string, locale: Locale): Promise<Translation>;
     getTranslation(scope: string, locale: Locale): Promise<Translation | null>;
     translate(request: LocalizationTranslationRequest): Promise<TranslationResult>;
@@ -1548,140 +1731,13 @@ declare abstract class RuntimePlugin<T extends PluginOptions = PluginOptions> ex
     executeCommand(ctx: CommandKitPluginRuntime, source: Interaction | Message$1, command: PreparedAppCommandExecution, execute: () => Promise<any>): Promise<boolean>;
 }
 
-declare class MemoryCache extends CacheProvider {
-    #private;
-    get<T>(key: string): Promise<CacheEntry<T> | undefined>;
-    set<T>(key: string, value: T, ttl?: number): Promise<void>;
-    exists(key: string): Promise<boolean>;
-    delete(key: string): Promise<void>;
-    clear(): Promise<void>;
-    expire(key: string, ttl: number): Promise<void>;
-}
-
-/**
- * Context for managing cache operations within an async scope
- */
-interface CacheContext {
-    params: {
-        /** Custom name for the cache entry */
-        name?: string;
-        /** Time-to-live in milliseconds */
-        ttl?: number;
-    };
-}
-/**
- * Represents an async function that can be cached
- * @template R - Array of argument types
- * @template T - Return type
- */
-type AsyncFunction<R extends any[] = any[], T = any> = (...args: R) => Promise<T>;
-/**
- * Configuration options for cache behavior
- */
-interface CacheMetadata {
-    /** Time-to-live duration in milliseconds or as a string (e.g., '1h', '5m') */
-    ttl?: number | string;
-    /** Custom name for the cache entry */
-    name?: string;
-}
-/**
- * Internal cache implementation
- * @internal
- * @private
- * This is used directly by the compiler if the function is annotated with `"use cache"` directive.
- * @example
- * ```ts
- * async function myCachedFunction() {
- *   "use cache";
- *   // can use cacheTag() and cacheLife() here to customize cache behavior
- *   return await db.query('SELECT * FROM users');
- * }
- * ```
- */
-declare function useCache<R extends any[], F extends AsyncFunction<R>>(fn: F, id?: string, params?: CacheMetadata): F;
-/**
- * Wraps an async function with caching capability
- * @template R - Array of argument types
- * @template F - Type of the async function
- * @param fn - The async function to cache
- * @param params - Optional cache configuration
- * @returns The wrapped function with caching behavior
- * @example
- * ```ts
- * const cachedFetch = cache(async (id: string) => {
- *   return await db.findOne(id);
- * }, { ttl: '1h' });
- * ```
- */
-declare function cache<R extends any[], F extends AsyncFunction<R>>(fn: F, params?: CacheMetadata): F;
-/**
- * Sets a custom identifier for the current cache operation
- * @param tag - The custom cache tag
- * @throws {Error} When called outside a cached function or without a tag
- * @example
- * ```ts
- * const fetchUser = cache(async (id: string) => {
- *   cacheTag(`user:${id}`);
- *   return await db.users.findOne(id);
- * });
- * ```
- */
-declare function cacheTag(tag: string): void;
-/**
- * Sets the TTL for the current cache operation
- * @param ttl - Time-to-live in milliseconds or as a string (e.g., '1h', '5m')
- * @throws {Error} When called outside a cached function or with invalid TTL
- * @example
- * ```ts
- * const fetchData = cache(async () => {
- *   cacheLife('30m');
- *   return await expensiveOperation();
- * });
- * ```
- */
-declare function cacheLife(ttl: number | string): void;
-/**
- * Removes a cached value by its tag
- * @param tag - The cache tag to invalidate
- * @throws {Error} When the cache key is not found
- * @example
- * ```ts
- * await invalidate('user:123');
- * ```
- */
-declare function invalidate(tag: string): Promise<void>;
-/**
- * Forces a refresh of cached data by its tag (on-demand revalidation)
- * @template T - Type of the cached value
- * @param tag - The cache tag to revalidate
- * @param args - Arguments to pass to the cached function
- * @returns Fresh data from the cached function
- * @throws {Error} When the cache key or function is not found
- * @example
- * ```ts
- * const freshData = await revalidate('user:123');
- * ```
- */
-declare function revalidate<T = unknown>(tag: string, ...args: any[]): Promise<T>;
-/**
- * Checks if a function is wrapped with cache functionality
- * @param fn - Function to check
- * @returns True if the function is cached
- * @example
- * ```ts
- * if (isCachedFunction(myFunction)) {
- *   console.log('Function is cached');
- * }
- * ```
- */
-declare function isCachedFunction(fn: GenericFunction): boolean;
-
 declare class CommandKitPluginRuntime extends EventTarget {
     readonly commandkit: CommandKit;
     private plugins;
     private onClientLogin;
     constructor(commandkit: CommandKit);
     getPlugin(pluginName: string): RuntimePlugin | null;
+    softRegisterPlugin(plugin: RuntimePlugin): Promise<void>;
     registerPlugin(plugin: RuntimePlugin): Promise<void>;
     unregisterPlugin(plugin: RuntimePlugin): Promise<void>;
     unregisterAllPlugins(): Promise<void>;
@@ -1706,6 +1762,7 @@ declare class CommandKit extends EventEmitter {
     readonly commandHandler: AppCommandHandler;
     readonly eventHandler: AppEventsHandler;
     readonly plugins: CommandKitPluginRuntime;
+    readonly events: CommandKitEventsChannel;
     static instance: CommandKit | undefined;
     /**
      * Create a new command and event handler with CommandKit.
@@ -1719,6 +1776,10 @@ declare class CommandKit extends EventEmitter {
      * @param token The application token to connect to the discord gateway. If not provided, it will use the `TOKEN` or `DISCORD_TOKEN` environment variable. If set to `false`, it will not login.
      */
     start(token?: string | false): Promise<void>;
+    /**
+     * Loads all the plugins.
+     */
+    loadPlugins(): Promise<void>;
     /**
      * Whether or not the commandkit application has started.
      */
@@ -1952,4 +2013,4 @@ declare const version: string;
  */
 declare function bootstrapCommandkitCLI(argv: string[], options?: commander.ParseOptions | undefined): Promise<void>;
 
-export { ActionRow, type ActionRowProps, type AnyCommandExecute, type AnyCommandKitElement, AppCommandHandler, type AsyncFunction, type AutocompleteCommand, type AutocompleteCommandContext, type AutocompleteCommandMiddlewareContext, type AutocompleteProps, Button, type ButtonChildrenLike, ButtonKit, type ButtonKitPredicate, type ButtonProps, type CacheContext, type CacheEntry, type CacheMetadata, CacheProvider, type CommandContext, type CommandContextOptions, type CommandData, CommandExecutionMode, type CommandFileObject, CommandKit, type CommandKitButtonBuilderInteractionCollectorDispatch, type CommandKitButtonBuilderInteractionCollectorDispatchContextData, type CommandKitButtonBuilderOnEnd, type CommandKitConfiguration, type CommandKitElement, type CommandKitElementData, CommandKitEnvironment, type CommandKitEnvironmentInternalData, CommandKitEnvironmentType, type CommandKitLoggerOptions, type CommandKitModalBuilderInteractionCollectorDispatch, type CommandKitModalBuilderInteractionCollectorDispatchContextData, type CommandKitModalBuilderOnEnd, type CommandKitOptions, type CommandObject, type CommandOptions, type CommandProps, CommandsRouter, type CommandsRouterOptions, type CommandsTree, Context, type ContextMenuCommandProps, type ContextParameters, DefaultLocalizationStrategy, DefaultLogger, ElementType, EventInterceptor, type EventInterceptorContextData, type EventInterceptorErrorHandler, EventsRouter, type EventsRouterOptions, type EventsTree, Fragment, type FragmentElementProps, type GenericFunction, type ILogger, type InteractionCommandContext, type InteractionCommandMiddlewareContext, type LoadedCommand, Localization, type LocalizationConfig, type LocalizationStrategy, type LocalizationTranslationRequest, Logger, type LoggerImpl, type MaybeArray, MemoryCache, type MessageCommand, type MessageCommandContext, type MessageCommandMiddlewareContext, MessageCommandOptions, type MessageCommandOptionsSchema, MessageCommandParser, type MessageContextMenuCommand, type MessageContextMenuCommandContext, type MessageContextMenuCommandMiddlewareContext, type MessageContextMenuCommandProps, MiddlewareContext, Modal, ModalKit, type ModalKitPredicate, type ModalProps, type OnButtonKitClick, type OnButtonKitEnd, type OnModalKitEnd, type OnModalKitSubmit, ParagraphInput, type ParsedCommand, type ParsedCommandsData, type ParsedEvent, type ParsedMessageCommand, type ParsedMiddleware, type ParsedSubCommand, type PreparedAppCommandExecution, type ReloadOptions, ReloadType, ShortInput, type SlashCommand, type SlashCommandContext, type SlashCommandMiddlewareContext, type SlashCommandProps, TextInput, type TextInputProps, type TranslatableArguments, type TranslatableCommand, type TranslatableCommandOptions, type Translation, type TranslationResult, type Translator, type UserContextMenuCommand, type UserContextMenuCommandContext, type UserContextMenuCommandMiddlewareContext, type UserContextMenuCommandProps, type ValidationProps, afterCommand, bootstrapCommandkitCLI, cache, cacheLife, cacheTag, cancelAfterCommand, createElement, createLogger, CommandKit as default, defineConfig, dmOnly, exitContext, exitMiddleware, getCommandKit, getConfig, getContext, getElement, guildOnly, invalidate, isCachedFunction, isCommandKitElement, makeContextAwareFunction, redirect, rethrow, revalidate, useCache as super_duper_secret_internal_for_use_cache_directive_of_commandkit_cli_do_not_use_it_directly_or_you_will_be_fired_from_your_job_kthxbai, useEnvironment, version };
+export { ActionRow, type ActionRowProps, type AnyCommandExecute, type AnyCommandKitElement, AppCommandHandler, type AsyncFunction, type AutocompleteCommand, type AutocompleteCommandContext, type AutocompleteCommandMiddlewareContext, type AutocompleteProps, Button, type ButtonChildrenLike, ButtonKit, type ButtonKitPredicate, type ButtonProps, type CacheContext, type CacheEntry, type CacheMetadata, CacheProvider, type CommandContext, type CommandContextOptions, type CommandData, CommandExecutionMode, type CommandFileObject, CommandKit, type CommandKitButtonBuilderInteractionCollectorDispatch, type CommandKitButtonBuilderInteractionCollectorDispatchContextData, type CommandKitButtonBuilderOnEnd, type CommandKitConfiguration, type CommandKitElement, type CommandKitElementData, CommandKitEnvironment, type CommandKitEnvironmentInternalData, CommandKitEnvironmentType, type CommandKitLoggerOptions, type CommandKitModalBuilderInteractionCollectorDispatch, type CommandKitModalBuilderInteractionCollectorDispatchContextData, type CommandKitModalBuilderOnEnd, type CommandKitOptions, type CommandObject, type CommandOptions, type CommandProps, type CommandTree, CommandsRouter, type CommandsRouterOptions, Context, type ContextMenuCommandProps, type ContextParameters, DefaultLocalizationStrategy, DefaultLogger, ElementType, EventInterceptor, type EventInterceptorContextData, type EventInterceptorErrorHandler, EventsRouter, type EventsRouterOptions, type EventsTree, Fragment, type FragmentElementProps, type GenericFunction, type ILogger, type InteractionCommandContext, type InteractionCommandMiddlewareContext, type LoadedCommand, Localization, type LocalizationConfig, type LocalizationStrategy, type LocalizationTranslationRequest, Logger, type LoggerImpl, type MaybeArray, MemoryCache, type MessageCommand, type MessageCommandContext, type MessageCommandMiddlewareContext, MessageCommandOptions, type MessageCommandOptionsSchema, MessageCommandParser, type MessageContextMenuCommand, type MessageContextMenuCommandContext, type MessageContextMenuCommandMiddlewareContext, type MessageContextMenuCommandProps, MiddlewareContext, Modal, ModalKit, type ModalKitPredicate, type ModalProps, type OnButtonKitClick, type OnButtonKitEnd, type OnModalKitEnd, type OnModalKitSubmit, ParagraphInput, type ParsedCommand, type ParsedCommandData, type ParsedEvent, type ParsedMessageCommand, type ParsedMiddleware, type ParsedSubCommand, type PreparedAppCommandExecution, type ReloadOptions, ReloadType, ShortInput, type SlashCommand, type SlashCommandContext, type SlashCommandMiddlewareContext, type SlashCommandProps, TextInput, type TextInputProps, type TranslatableArguments, type TranslatableCommand, type TranslatableCommandOptions, type Translation, type TranslationResult, type Translator, type UserContextMenuCommand, type UserContextMenuCommandContext, type UserContextMenuCommandMiddlewareContext, type UserContextMenuCommandProps, type ValidationProps, afterCommand, bootstrapCommandkitCLI, cache, cacheLife, cacheTag, cancelAfterCommand, createElement, createLogger, CommandKit as default, defineConfig, dmOnly, exitContext, exitMiddleware, getCommandKit, getConfig, getContext, getElement, guildOnly, invalidate, isCachedFunction, isCommandKitElement, makeContextAwareFunction, redirect, rethrow, revalidate, useCache as super_duper_secret_internal_for_use_cache_directive_of_commandkit_cli_do_not_use_it_directly_or_you_will_be_fired_from_your_job_kthxbai, useEnvironment, version };