commandkit 0.1.11-dev.20250306101654 → 0.1.11-dev.20250307192025

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as discord_js from 'discord.js';
-import { RESTPostAPIApplicationCommandsJSONBody, Client, Interaction, CacheType, PermissionsString, ChatInputCommandInteraction, ContextMenuCommandInteraction, UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction, AutocompleteInteraction, ClientEvents, Awaitable, ButtonBuilder, ButtonInteraction, Events, ModalBuilder, ModalSubmitInteraction, ActionRowBuilder, TextInputBuilder, ButtonStyle, ComponentEmojiResolvable, TextInputStyle, Locale, Message as Message$1, ApplicationCommandOptionType, GuildMember, Attachment, User, Role, CommandInteractionOption, SlashCommandBuilder, ContextMenuCommandBuilder, PartialMessage } from 'discord.js';
+import { RESTPostAPIApplicationCommandsJSONBody, Client, Interaction, CacheType, PermissionsString, ChatInputCommandInteraction, ContextMenuCommandInteraction, UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction, AutocompleteInteraction, ClientEvents, Awaitable, ButtonBuilder, ButtonInteraction, Events, ModalBuilder, ModalSubmitInteraction, ActionRowBuilder, TextInputBuilder, ButtonStyle, ComponentEmojiResolvable, TextInputStyle, Locale, Message as Message$1, ApplicationCommandOptionType, GuildMember, Attachment, User, Role, CommandInteractionOption, Collection, SlashCommandBuilder, ContextMenuCommandBuilder, PartialMessage } from 'discord.js';
 import EventEmitter from 'node:events';
 import { Channel } from 'diagnostics_channel';
 import * as commander from 'commander';
@@ -1008,163 +1008,154 @@ declare class MiddlewareContext<T extends CommandExecutionMode = CommandExecutio
 }
 
 /**
- * Matcher type for identifying command and middleware files.
- * Can be a string suffix (e.g. '.cmd.js'), RegExp pattern, or custom matcher function.
+ * 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.
  */
-type CommandsRouterMatcher = string | RegExp | ((path: string) => boolean);
-/**
- * Maps file type identifiers to their respective matchers.
- * Used to identify command and middleware files in the directory structure.
- */
-type CommandsRouterMatchersMap = Record<'command' | 'middleware', CommandsRouterMatcher>;
-/**
- * Configuration options for the CommandsRouter
- */
-interface CommandsRouterOptions {
+interface ParsedCommand {
     /**
-     * The path to the directory containing the command files.
+     * The unique identifier of the command. This is used to distinguish between commands that may have the same name.
      */
-    entrypoint: string;
+    id: string;
     /**
-     * The path to the directory containing the middleware files.
+     * The file name of the command.
      */
-    matcher?: Partial<CommandsRouterMatchersMap>;
-}
-/**
- * Represents a parsed command with its metadata
- * @interface ParsedCommand
- */
-interface ParsedCommand {
-    /** Command name derived from the file name without extension */
     name: string;
-    /** Absolute file system path to the command file */
+    /**
+     * The absolute path to the command file.
+     */
     path: string;
-    /** Parent command name for nested commands, or null if root-level command */
-    parent: string | null;
-    /** Array of command segments representing the command hierarchy */
-    parentSegments: string[];
-    /** Array of middleware IDs that apply to this command */
-    middlewares: string[];
-    /** Absolute path to this command */
-    fullPath: string;
-    /** Category the command belongs to, if any */
+    /**
+     * The relative path from the cwd to the command file.
+     */
+    relativePath: string;
+    /**
+     * 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+)/`.
+     */
     category: string | null;
+    /**
+     * Array of ids referencing the associated middleware for this command.
+     */
+    middlewares: string[];
+    /**
+     * Array of ids referencing the associated subcommands for this command.
+     */
+    subcommands: string[];
 }
 /**
- * Represents a parsed middleware with its metadata
- * @interface ParsedMiddleware
+ * Represents a middleware file info parsed from the file system.
  */
 interface ParsedMiddleware {
-    /** Unique identifier used to reference this middleware */
-    id: string;
-    /** Middleware name derived from the file path */
-    name: string;
-    /** Path to the middleware file, relative to the entrypoint */
-    path: string;
-    /** Absolute path to the middleware file */
-    fullPath: string;
-    /** Category the middleware belongs to, if any */
-    category: string | null;
-}
-/**
- * Complete tree structure of all commands and middleware
- * @interface CommandsTree
- */
-interface CommandsTree {
-    /** Map of command names to their parsed metadata */
-    commands: Record<string, ParsedCommand>;
-    /** Map of middleware IDs to their parsed metadata */
-    middleware: Record<string, ParsedMiddleware>;
-}
-/**
- * Result of a successful command match operation
- * @interface CommandMatchResult
- */
-interface CommandMatchResult {
-    /** The matched command metadata */
-    command: ParsedCommand;
-    /** Array of middleware that apply to the matched command */
-    middlewares: ParsedMiddleware[];
-}
-/**
- * CommandsRouter handles the discovery and routing of commands and middleware files
- * in a directory structure. It supports nested commands and middleware inheritance.
- */
-declare class CommandsRouter {
-    private readonly options;
-    private commands;
-    private middlewares;
-    /**
-     * Creates a new CommandsRouter instance
-     * @param options - Configuration options for the router
-     */
-    constructor(options: CommandsRouterOptions);
     /**
-     * Gets the configured entrypoint directory
+     * The unique identifier of the middleware. This is used to distinguish between middlewares that may have the same name.
      */
-    get entrypoint(): string;
+    id: string;
     /**
-     * Gets the configured matchers for command and middleware files
+     * The file name of the middleware.
      */
-    get matchers(): CommandsRouterMatchersMap;
+    name: string;
     /**
-     * Returns the cached data of the commands and middleware
+     * The absolute path to the middleware file.
      */
-    getData(): {
-        commands: Map<string, ParsedCommand>;
-        middleware: Map<string, ParsedMiddleware>;
-    };
+    path: string;
     /**
-     * Checks if the entrypoint path is valid
+     * The relative path from the cwd to the middleware file.
      */
-    isValidPath(): boolean;
+    relativePath: string;
     /**
-     * Executes a matcher against a file path
-     * @param matcher - The matcher to use
-     * @param path - The file path to test
-     * @returns boolean indicating if the path matches
+     * The category of this middleware. This will be the parent directory segment that matches /(category)/ in the path.
      */
-    private execMatcher;
+    category: string | null;
+}
+/**
+ * Represents a subcommand file info parsed from the file system.
+ */
+interface ParsedSubCommand {
     /**
-     * Converts an absolute path to a path relative to the entrypoint
-     * @param path - The absolute path to convert
+     * The unique identifier of the subcommand. This is used to distinguish between subcommands that may have the same name.
      */
-    private resolveRelativePath;
+    id: string;
     /**
-     * Matches a command by name or path segments
-     * @param commandOrSegment - Command name or array of path segments
-     * @returns Matched command and its middlewares, or null if no match
+     * The name of the subcommand.
      */
-    match(commandOrSegment: string | string[]): CommandMatchResult | null;
+    name: string;
     /**
-     * Reloads the commands tree by re-scanning the entrypoint directory
+     * The group name of the subcommand. This is used to group subcommands together in the Discord UI.
      */
-    reload(): Promise<CommandsTree>;
+    group: string | null;
     /**
-     * Clears the internal commands and middleware maps
+     * The absolute path to the subcommand file.
      */
-    clear(): void;
+    path: string;
     /**
-     * Scans the entrypoint directory for commands and middleware
-     * @returns Promise resolving to the complete commands tree
+     * The relative path from the cwd to the subcommand file.
      */
-    scan(): Promise<CommandsTree>;
+    relativePath: string;
     /**
-     * Converts the internal maps to a serializable object
-     * @returns CommandsTree containing all commands and middleware
+     * Array of ids referencing the associated middleware for this subcommand.
      */
-    toJSON(): CommandsTree;
+    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>;
+}
+/**
+ * Represents the scanned and parsed command files.
+ */
+interface ParsedCommandData {
+    commands: Collection<string, ParsedCommand>;
+    middlewares: Collection<string, ParsedMiddleware>;
+    subcommands: Collection<string, ParsedSubCommand>;
+}
+interface CommandsRouterOptions {
     /**
-     * Recursively scans a directory for files
-     * @param dir - Directory to scan
-     * @param entries - Accumulator for found files
-     * @returns Promise resolving to array of file paths
+     * The path to the directory containing the command files.
      */
-    private scanDirectory;
-    private isIgnoredFile;
-    private isCommandFile;
-    private parseCategories;
-    private parseCommandPath;
+    entrypoint: string;
+}
+declare class CommandsRouter {
+    private options;
+    private commands;
+    private middlewares;
+    private subcommands;
+    constructor(options: CommandsRouterOptions);
+    isValidPath(): boolean;
+    get entrypoint(): string;
+    clear(): void;
+    reload(): Promise<CommandTree>;
+    visualize(): string;
+    getData(): ParsedCommandData;
+    toJSON(): CommandTree;
+    scan(): Promise<CommandTree>;
+    private scanDeep;
+    private processMiddleware;
+    private processSubcommand;
+    private processCommand;
+    /**
+     * 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;
 }
 
 /**
@@ -1261,6 +1252,10 @@ declare class CommandRegistrar {
      * Gets the commands data.
      */
     getCommandsData(): CommandData[];
+    /**
+     * Process and merge subcommands into the parent command's options
+     */
+    private processSubcommands;
     /**
      * Registers loaded commands.
      */
@@ -1290,6 +1285,7 @@ interface AppCommandMiddleware {
 interface LoadedCommand {
     command: ParsedCommand;
     data: AppCommand;
+    subcommands?: ParsedSubCommand[];
     guilds?: string[];
 }
 interface LoadedMiddleware {
@@ -1298,29 +1294,192 @@ interface LoadedMiddleware {
 }
 interface PreparedAppCommandExecution {
     command: LoadedCommand;
+    subcommand?: LoadedSubCommand | null;
     middlewares: LoadedMiddleware[];
     messageCommandParser?: MessageCommandParser;
 }
+interface LoadedSubCommand {
+    subcommand: ParsedSubCommand;
+    data: AppCommand;
+}
 type CommandBuilderLike = SlashCommandBuilder | ContextMenuCommandBuilder | Record<string, any>;
 declare class AppCommandHandler {
     readonly commandkit: CommandKit;
     private loadedCommands;
+    private loadedSubCommands;
     private loadedMiddlewares;
+    private commandNameToId;
+    private subcommandPathToId;
     readonly registrar: CommandRegistrar;
     private onInteraction;
     private onMessageCreate;
     private onMessageUpdate;
     constructor(commandkit: CommandKit);
     getCommandsArray(): LoadedCommand[];
+    /**
+     * Get subcommand data by ID for the command registrar
+     */
+    getSubcommandData(id: string): any;
     registerCommandHandler(): void;
     getExecutionMode(source: Interaction | Message$1): CommandExecutionMode;
-    runCommand(command: PreparedAppCommandExecution, source: Interaction | Message$1): Promise<void>;
+    runCommand(prepared: PreparedAppCommandExecution, source: Interaction | Message$1): Promise<void>;
     prepareCommandRun(source: Interaction | Message$1): Promise<PreparedAppCommandExecution | null>;
     reloadCommands(): Promise<void>;
     loadCommands(): Promise<void>;
+    private loadMiddleware;
+    private loadCommand;
+    private loadSubcommand;
     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;
@@ -1484,6 +1643,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>;
@@ -1561,140 +1721,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>;
@@ -1719,6 +1752,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.
@@ -1732,6 +1766,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.
      */
@@ -1965,4 +2003,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 CommandMatchResult, type CommandObject, type CommandOptions, type CommandProps, CommandsRouter, type CommandsRouterMatcher, type CommandsRouterMatchersMap, 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 ParsedEvent, type ParsedMessageCommand, type ParsedMiddleware, 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 };