commandkit 0.1.11-dev.20250208131735 → 0.1.11-dev.20250213182706

package/dist/index.d.mts

@@ -1,6 +1,7 @@
 import * as discord_js from 'discord.js';
-import { Client, Interaction, CacheType, ChatInputCommandInteraction, ContextMenuCommandInteraction, UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction, AutocompleteInteraction, PermissionsString, RESTPostAPIApplicationCommandsJSONBody, ClientEvents, Awaitable, ButtonInteraction, Events, ButtonBuilder, ModalSubmitInteraction, ModalBuilder, ActionRowBuilder, TextInputBuilder, ButtonStyle, ComponentEmojiResolvable, TextInputStyle } from 'discord.js';
+import { Client, Interaction, CacheType, ChatInputCommandInteraction, ContextMenuCommandInteraction, UserContextMenuCommandInteraction, MessageContextMenuCommandInteraction, AutocompleteInteraction, PermissionsString, RESTPostAPIApplicationCommandsJSONBody, ClientEvents, Awaitable, ButtonInteraction, Events, ButtonBuilder, ModalSubmitInteraction, ModalBuilder, ActionRowBuilder, TextInputBuilder, ButtonStyle, ComponentEmojiResolvable, TextInputStyle, Locale, ApplicationCommandOptionType, Message, GuildMember, Attachment, User, Role, CommandInteractionOption, SlashCommandBuilder, ContextMenuCommandBuilder } from 'discord.js';
 import EventEmitter from 'node:events';
+import { Channel } from 'diagnostics_channel';
 import * as commander from 'commander';
 
 interface CacheEntry<T = unknown> {
@@ -345,6 +346,238 @@ interface EventHandlerOptions {
     commandKitInstance: CommandKit;
 }
 
+/**
+ * Matcher type for identifying command and middleware files.
+ * Can be a string suffix (e.g. '.cmd.js'), RegExp pattern, or custom matcher function.
+ */
+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 {
+    /**
+     * The path to the directory containing the command files.
+     */
+    entrypoint: string;
+    /**
+     * The path to the directory containing the middleware files.
+     */
+    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 */
+    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;
+}
+/**
+ * Represents a parsed middleware with its metadata
+ * @interface ParsedMiddleware
+ */
+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;
+}
+/**
+ * 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
+     */
+    get entrypoint(): string;
+    /**
+     * Gets the configured matchers for command and middleware files
+     */
+    get matchers(): CommandsRouterMatchersMap;
+    /**
+     * Returns the cached data of the commands and middleware
+     */
+    getData(): {
+        commands: Map<string, ParsedCommand>;
+        middleware: Map<string, ParsedMiddleware>;
+    };
+    /**
+     * Checks if the entrypoint path is valid
+     */
+    isValidPath(): boolean;
+    /**
+     * 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
+     */
+    private execMatcher;
+    /**
+     * Converts an absolute path to a path relative to the entrypoint
+     * @param path - The absolute path to convert
+     */
+    private resolveRelativePath;
+    /**
+     * 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
+     */
+    match(commandOrSegment: string | string[]): CommandMatchResult | null;
+    /**
+     * Reloads the commands tree by re-scanning the entrypoint directory
+     */
+    reload(): Promise<CommandsTree>;
+    /**
+     * Clears the internal commands and middleware maps
+     */
+    clear(): void;
+    /**
+     * Scans the entrypoint directory for commands and middleware
+     * @returns Promise resolving to the complete commands tree
+     */
+    scan(): Promise<CommandsTree>;
+    /**
+     * Converts the internal maps to a serializable object
+     * @returns CommandsTree containing all commands and middleware
+     */
+    toJSON(): CommandsTree;
+    /**
+     * 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
+     */
+    private scanDirectory;
+}
+
+/**
+ * Configuration options for the EventsRouter
+ * @interface EventsRouterOptions
+ */
+interface EventsRouterOptions {
+    /** Root directory path where event handlers are located */
+    entrypoint: string;
+}
+/**
+ * Represents a parsed event with its handlers
+ * @interface ParsedEvent
+ */
+interface ParsedEvent {
+    /** Name of the event derived from directory name */
+    event: string;
+    /** Absolute path to the event directory */
+    path: string;
+    /** Array of file paths to event listener handlers */
+    listeners: string[];
+}
+/** Map of event names to their parsed metadata */
+type EventsTree = Record<string, ParsedEvent>;
+/**
+ * Router for discovering and managing event handler files in a directory structure.
+ * Events are represented by directories, and handlers are files within those directories.
+ */
+declare class EventsRouter {
+    private options;
+    /** Internal storage of parsed events */
+    private events;
+    /**
+     * Creates a new EventsRouter instance
+     * @param options - Configuration options for the router
+     * @throws Error if entrypoint is not provided
+     */
+    constructor(options: EventsRouterOptions);
+    /**
+     * Find a parsed event by its name
+     * @param event - Name of the event to find
+     * @returns Parsed event metadata or null if not found
+     */
+    match(event: string): ParsedEvent | null;
+    /**
+     * Get the entrypoint directory path
+     * @returns Entrypoint directory path
+     */
+    get entrypoint(): string;
+    /**
+     * Checks if the entrypoint path is valid
+     */
+    isValidPath(): boolean;
+    /**
+     * Clear all parsed events
+     */
+    clear(): void;
+    /**
+     * Reload and re-scan the entrypoint directory for events
+     * @returns Promise resolving to the updated events tree
+     */
+    reload(): Promise<EventsTree>;
+    /**
+     * Scan the entrypoint directory for events and their handlers
+     * @returns Promise resolving to the events tree
+     */
+    scan(): Promise<EventsTree>;
+    /**
+     * Convert the internal events map to a plain object
+     * @returns Events tree as a plain object
+     */
+    toJSON(): EventsTree;
+    /**
+     * Recursively scan a directory for event handlers
+     * @param event - Name of the event
+     * @param path - Path to the event directory
+     * @param listeners - Array to collect listener file paths
+     * @returns Promise resolving to the parsed event metadata
+     */
+    private scanEvent;
+}
+
 /**
  * A handler for client events.
  */
@@ -352,6 +585,8 @@ declare class EventHandler {
     #private;
     constructor({ ...options }: EventHandlerOptions);
     init(): Promise<void>;
+    registerExternal(entry: ParsedEvent): Promise<void>;
+    resyncListeners(): void;
     get events(): {
         name: string;
         functions: Function[];
@@ -372,11 +607,20 @@ interface EventInterceptorContextData<E extends keyof ClientEvents> {
      * If the collector should automatically reset the timer when a button is clicked.
      */
     autoReset?: boolean;
+    /**
+     * Whether the collector should run only once.
+     */
+    once?: boolean;
     /**
      * The handler to run when the collector ends.
      */
     onEnd?: (reason: string) => Awaitable<void>;
+    /**
+     * The handler to run upon an error.
+     */
+    onError?: EventInterceptorErrorHandler;
 }
+type EventInterceptorErrorHandler = (error: Error) => Awaitable<void>;
 declare class EventInterceptor {
     #private;
     readonly client: Client;
@@ -444,7 +688,7 @@ type OnButtonKitEnd = CommandKitButtonBuilderOnEnd;
  * The handler to run when a button is clicked. This handler is called with the interaction as the first argument.
  * If the first argument is null, it means that the interaction collector has been destroyed.
  */
-type CommandKitButtonBuilderInteractionCollectorDispatch = (interaction: ButtonInteraction) => Awaitable<void>;
+type CommandKitButtonBuilderInteractionCollectorDispatch = (interaction: ButtonInteraction, context: ButtonKit) => Awaitable<void>;
 type CommandKitButtonBuilderOnEnd = (reason: string) => Awaitable<void>;
 type CommandKitButtonBuilderInteractionCollectorDispatchContextData = EventInterceptorContextData<Events.InteractionCreate>;
 declare class ButtonKit extends ButtonBuilder {
@@ -476,6 +720,12 @@ declare class ButtonKit extends ButtonBuilder {
      */
     onClick(handler: CommandKitButtonBuilderInteractionCollectorDispatch, data?: CommandKitButtonBuilderInteractionCollectorDispatchContextData): this;
     onEnd(handler: CommandKitButtonBuilderOnEnd): this;
+    /**
+     * Sets the handler to run when the interaction collector ends.
+     * @param handler - The handler to run when the interaction collector ends.
+     * @returns This instance of the modal builder.
+     */
+    onError(handler: EventInterceptorErrorHandler): this;
     /**
      * Sets a filter for the interaction collector.
      * @param predicate The filter to use for the interaction collector
@@ -500,7 +750,7 @@ type OnModalKitEnd = CommandKitModalBuilderOnEnd;
  * The handler to run when a modal is submitted. This handler is called with the interaction as the first argument.
  * If the first argument is null, it means that the interaction collector has been destroyed.
  */
-type CommandKitModalBuilderInteractionCollectorDispatch = (interaction: ModalSubmitInteraction) => Awaitable<void>;
+type CommandKitModalBuilderInteractionCollectorDispatch = (interaction: ModalSubmitInteraction, context: ModalKit) => Awaitable<void>;
 type CommandKitModalBuilderOnEnd = (reason: string) => Awaitable<void>;
 type CommandKitModalBuilderInteractionCollectorDispatchContextData = EventInterceptorContextData<Events.InteractionCreate>;
 declare class ModalKit extends ModalBuilder {
@@ -529,6 +779,12 @@ declare class ModalKit extends ModalBuilder {
      * @returns This instance of the modal builder.
      */
     onEnd(handler: CommandKitModalBuilderOnEnd): this;
+    /**
+     * Sets the handler to run when the interaction collector ends.
+     * @param handler - The handler to run when the interaction collector ends.
+     * @returns This instance of the modal builder.
+     */
+    onError(handler: EventInterceptorErrorHandler): this;
     /**
      * Sets a filter for the interaction collector.
      * @param predicate - The filter to use for the interaction collector.
@@ -585,6 +841,7 @@ interface ButtonProps {
     url?: string;
     skuId?: string;
     onClick?: CommandKitButtonBuilderInteractionCollectorDispatch;
+    onError?: EventInterceptorErrorHandler;
     options?: CommandKitButtonBuilderInteractionCollectorDispatchContextData;
     onEnd?: CommandKitButtonBuilderOnEnd;
     children?: MaybeArray<ButtonChildrenLike>;
@@ -603,6 +860,7 @@ interface ModalProps {
     children?: MaybeArray<TextInputBuilder | ActionRowBuilder>;
     onSubmit?: OnModalKitSubmit;
     onEnd?: OnModalKitEnd;
+    onError?: EventInterceptorErrorHandler;
     options?: CommandKitModalBuilderInteractionCollectorDispatchContextData;
 }
 /**
@@ -645,11 +903,459 @@ declare function ShortInput(props: TextInputProps): CommandKitElement<'text-inpu
  */
 declare function ParagraphInput(props: TextInputProps): CommandKitElement<'text-input'>;
 
+interface TranslatableCommand {
+    name?: string;
+    description?: string;
+    options?: TranslatableCommandOptions[];
+}
+interface TranslatableCommandOptions {
+    ref: string;
+    name?: string;
+    description?: string;
+}
+interface Translation {
+    command: TranslatableCommand;
+    translations: TranslatableArguments;
+}
+type TranslatableArguments = Record<string, string>;
+
+interface LocalizationTranslationRequest {
+    locale: Locale;
+    scope: string;
+    key: string;
+    args?: Record<string, any> | undefined;
+}
+type TranslationResult = string;
+interface LocalizationStrategy {
+    locateTranslation(scope: string, locale: Locale): Promise<Translation | null>;
+    getTranslation(scope: string, locale: Locale): Promise<Translation | null>;
+    getTranslationStrict(scope: string, locale: Locale): Promise<Translation>;
+    translate(request: LocalizationTranslationRequest): Promise<TranslationResult>;
+}
+
+interface LocalizationConfig {
+    /**
+     * The locale to use for localization.
+     */
+    locale: Locale;
+    /**
+     * The internalization data target.
+     */
+    target: string;
+}
+type Translator = (translatable: string, args?: TranslatableArguments | undefined) => Promise<TranslationResult>;
+declare class Localization {
+    private readonly commandkit;
+    private readonly config;
+    /**
+     * Translates the given translatable object.
+     * @param translatable The translatable object to translate.
+     */
+    readonly t: Translator;
+    /**
+     * Creates a new localization instance.
+     * @param commandkit The command kit instance.
+     * @param config The localization configuration.
+     */
+    constructor(commandkit: CommandKit, config: LocalizationConfig);
+    /**
+     * Get the localization strategy.
+     */
+    getStrategy(): LocalizationStrategy;
+    /**
+     * Get the default locale
+     */
+    getDefaultLocale(): Locale;
+    /**
+     * Get the current locale
+     */
+    getLocale(): Locale;
+    /**
+     * Get the localization target
+     */
+    getTarget(): string;
+}
+
+interface ParsedMessageCommand {
+    command: string;
+    options: {
+        name: string;
+        value: unknown;
+    }[];
+    subcommand?: string;
+    subcommandGroup?: string;
+}
+type MessageCommandOptionsSchema = Record<string, ApplicationCommandOptionType>;
+declare class MessageCommandParser {
+    #private;
+    message: Message;
+    private prefix;
+    private schema;
+    constructor(message: Message, prefix: string[], schema: (command: string) => MessageCommandOptionsSchema);
+    getArgs(): string[];
+    get options(): MessageCommandOptions;
+    getOption<T>(name: string): T | undefined;
+    getCommand(): string;
+    getSubcommand(): string | undefined;
+    getSubcommandGroup(): string | undefined;
+    getPrefix(): string | undefined;
+    getFullCommand(): string;
+    parse(): ParsedMessageCommand;
+}
+declare class MessageCommandOptions {
+    private parser;
+    constructor(parser: MessageCommandParser);
+    private assertOption;
+    getMember(name: string): GuildMember | null;
+    getMember(name: string, required: true): GuildMember;
+    getAttachment(name: string): Attachment | null;
+    getAttachment(name: string, required: true): Attachment;
+    getBoolean(name: string): boolean | null;
+    getBoolean(name: string, required: true): boolean;
+    getNumber(name: string): number | null;
+    getNumber(name: string, required: true): number;
+    getString(name: string): string | null;
+    getString(name: string, required: true): string;
+    getInteger(name: string): number | null;
+    getInteger(name: string, required: true): number;
+    getUser(name: string): User | null;
+    getUser(name: string, required: true): User;
+    getChannel(name: string): Channel | null;
+    getChannel(name: string, required: true): Channel;
+    getRole(name: string): Role | null;
+    getRole(name: string, required: true): Role;
+    getMentionable(name: string): NonNullable<CommandInteractionOption['member' | 'role' | 'user']> | null;
+    getMentionable(name: string, required: true): NonNullable<CommandInteractionOption['member' | 'role' | 'user']>;
+    getSubcommand(): string | null;
+    getSubcommand(required: true): string;
+    getSubcommandGroup(): string | null;
+    getSubcommandGroup(required: true): string;
+}
+
+type GenericFunction<A extends any[] = any[]> = (...args: A) => any;
+declare function exitContext<T>(fn: () => T): T;
+/**
+ * Returns a context-aware version of the given function.
+ * @param env - The commandkit environment data.
+ * @param fn - The target function.
+ * @param finalizer - An optional finalizer function to run after the target function. This function will be context-aware.
+ * @internal
+ */
+declare function makeContextAwareFunction<R extends GenericFunction, F extends GenericFunction>(env: CommandKitEnvironment, fn: R, finalizer?: F): R;
+/**
+ * Retrieves commandkit
+ * @private
+ * @internal
+ */
+declare function getCommandKit(): CommandKit | undefined;
+declare function getCommandKit(strict: true): CommandKit;
+declare function getCommandKit(strict: false): CommandKit | undefined;
+/**
+ * Get the current commandkit context.
+ * @internal
+ */
+declare function getContext(): CommandKitEnvironment | undefined;
+/**
+ * Use current commandkit context. Throws an error if no context is found.
+ */
+declare function useEnvironment(): CommandKitEnvironment;
+/**
+ * Ensures the command is only available in guilds.
+ * Note: do not wrap this function in a try/catch block.
+ */
+declare function guildOnly(): void;
+/**
+ * Ensures the command is only available in DMs.
+ * Note: do not wrap this function in a try/catch block.
+ */
+declare function dmOnly(): void;
+
+interface CommandKitEnvironmentInternalData {
+    executionError: Error | null;
+    type: CommandKitEnvironmentType | null;
+    variables: Map<string, any>;
+    deferredFunctions: Map<string, GenericFunction<[CommandKitEnvironment]>>;
+    marker: string;
+    markStart: number;
+    markEnd: number;
+}
+declare class CommandKitEnvironment {
+    #private;
+    readonly commandkit: CommandKit;
+    /**
+     * Creates the commandkit execution environment.
+     * @param commandkit - The commandkit instance.
+     */
+    constructor(commandkit: CommandKit);
+    /**
+     * Get the execution error.
+     * @internal
+     */
+    getExecutionError(): Error | null;
+    /**
+     * Set the execution error.
+     * @param error - The error to set.
+     * @internal
+     */
+    setExecutionError(error: Error): void;
+    /**
+     * Get the environment type.
+     */
+    getType(): CommandKitEnvironmentType;
+    /**
+     * Set the environment type.
+     * @param type - The environment type to set.
+     * @internal
+     */
+    setType(type: CommandKitEnvironmentType): void;
+    /**
+     * The variables store for this environment.
+     */
+    get variables(): Map<string, any>;
+    /**
+     * Register a deferred function.
+     * @param fn - The deferred function to register.
+     * @returns The deferred function id.
+     * @internal
+     */
+    registerDeferredFunction(fn: GenericFunction<[CommandKitEnvironment]>): string;
+    /**
+     * Clear a deferred function by id.
+     * @param id - The deferred function id to clear.
+     * @internal
+     */
+    clearDeferredFunction(id: string): void;
+    /**
+     * Run all deferred functions sequentially.
+     * @internal
+     */
+    runDeferredFunctions(): Promise<void>;
+    /**
+     * Clear all deferred functions.
+     * @internal
+     */
+    clearAllDeferredFunctions(): void;
+    /**
+     * Mark the start of a command execution.
+     * @param marker - The marker to set.
+     * @internal
+     */
+    markStart(marker: string): void;
+    /**
+     * Mark the end of a command execution.
+     * @internal
+     */
+    markEnd(): void;
+    /**
+     * Get the marker.
+     * @internal
+     */
+    getMarker(): string;
+    /**
+     * Get the execution time in milliseconds.
+     * @internal
+     */
+    getExecutionTime(): number;
+}
+declare enum CommandKitEnvironmentType {
+    CommandHandler = "COMMAND_HANDLER"
+}
+/**
+ * Runs the given function after the current command has finished executing.
+ * @param fn The function to run after the current command.
+ * @returns The deferred function id. This can be used to cancel the deferred function.
+ */
+declare function afterCommand(fn: GenericFunction<[CommandKitEnvironment]>): string;
+/**
+ * Cancels a deferred function registered with `afterCommand`.
+ * @param id The deferred function id to cancel.
+ */
+declare function cancelAfterCommand(id: string): void;
+
+declare const CommandExecutionMode: {
+    readonly SlashCommand: "chatInput";
+    readonly MessageContextMenu: "messageContextMenu";
+    readonly UserContextMenu: "userContextMenu";
+    readonly Autocomplete: "autocomplete";
+    readonly Message: "message";
+};
+type CommandExecutionMode = (typeof CommandExecutionMode)[keyof typeof CommandExecutionMode];
+interface ContextParameters<T extends CommandExecutionMode> {
+    environment?: CommandKitEnvironment;
+    executionMode: T;
+    interaction: T extends 'chatInput' ? ChatInputCommandInteraction : T extends 'messageContextMenu' ? MessageContextMenuCommandInteraction : T extends 'userContextMenu' ? UserContextMenuCommandInteraction : T extends 'autocomplete' ? AutocompleteInteraction : never;
+    message: T extends 'message' ? Message : never;
+    forwarded?: boolean;
+    messageCommandParser?: T extends 'message' ? MessageCommandParser : never;
+}
+type MessageCommandContext = Context<'message'>;
+type InteractionCommandContext = Context<'autocomplete' | 'chatInput' | 'messageContextMenu' | 'userContextMenu'>;
+type MessageCommandMiddlewareContext = MiddlewareContext<'message'>;
+type InteractionCommandMiddlewareContext = MiddlewareContext<'autocomplete' | 'chatInput' | 'messageContextMenu' | 'userContextMenu'>;
+type SlashCommandContext = Context<'chatInput'>;
+type SlashCommandMiddlewareContext = MiddlewareContext<'chatInput'>;
+type AutocompleteCommandContext = Context<'autocomplete'>;
+type AutocompleteCommandMiddlewareContext = MiddlewareContext<'autocomplete'>;
+type MessageContextMenuCommandContext = Context<'messageContextMenu'>;
+type MessageContextMenuCommandMiddlewareContext = MiddlewareContext<'messageContextMenu'>;
+type UserContextMenuCommandContext = Context<'userContextMenu'>;
+type UserContextMenuCommandMiddlewareContext = MiddlewareContext<'userContextMenu'>;
+type CommandContextOptions<T extends CommandExecutionMode> = T extends 'message' ? MessageCommandOptions : T extends 'chatInput' ? ChatInputCommandInteraction['options'] : T extends 'autocomplete' ? AutocompleteInteraction['options'] : T extends 'messageContextMenu' ? MessageContextMenuCommandInteraction['options'] : T extends 'userContextMenu' ? UserContextMenuCommandInteraction['options'] : never;
+declare class Context<ExecutionMode extends CommandExecutionMode = CommandExecutionMode> {
+    readonly commandkit: CommandKit;
+    private readonly config;
+    /**
+     * The interaction that triggered the command.
+     */
+    readonly interaction: ContextParameters<ExecutionMode>['interaction'];
+    /**
+     * The message that triggered the command.
+     */
+    readonly message: ContextParameters<ExecutionMode>['message'];
+    private _locale;
+    /**
+     * Creates a new command context.
+     * @param commandkit The command kit instance.
+     * @param config The context parameters.
+     */
+    constructor(commandkit: CommandKit, config: ContextParameters<ExecutionMode>);
+    get commandName(): string;
+    get options(): CommandContextOptions<ExecutionMode>;
+    /**
+     * Whether this context was forwarded from another context. This happens when a command forwards its context to another command.
+     */
+    get forwarded(): boolean;
+    /**
+     * Forwards the context to another command. The target handler will be the same as current handler.
+     * @param command The command to forward to.
+     */
+    forwardCommand(command: string): Promise<never>;
+    /**
+     * The execution mode of the command.
+     */
+    get executionMode(): ExecutionMode;
+    /**
+     * Whether the command was triggered by an interaction.
+     */
+    isInteraction(): this is InteractionCommandContext;
+    /**
+     * Whether the command was triggered by a slash command interaction.
+     */
+    isSlashCommand(): this is SlashCommandContext;
+    /**
+     * Whether the command was triggered by an autocomplete interaction.
+     */
+    isAutocomplete(): this is AutocompleteCommandContext;
+    /**
+     * Whether the command was triggered by a message context menu interaction.
+     */
+    isMessageContextMenu(): this is MessageContextMenuCommandContext;
+    /**
+     * Whether the command was triggered by a user context menu interaction.
+     */
+    isUserContextMenu(): this is UserContextMenuCommandContext;
+    /**
+     * Whether the command was triggered by a message.
+     */
+    isMessage(): this is Context<'message'>;
+    /**
+     * Returns the command identifier.
+     */
+    getCommandIdentifier(): string;
+    /**
+     * Returns the locale of the guild where this command was triggered.
+     */
+    getGuildLocale(): Locale | null;
+    /**
+     * Returns the locale of the user who triggered this command.
+     */
+    getUserLocale(): Locale | null;
+    /**
+     * Returns the locale for this command.
+     * @param preferUser Whether to prefer the user's locale over the guild's locale.
+     * @returns The locale for this command. If no locale is found, the default locale is returned.
+     */
+    getLocale(preferUser?: boolean): Locale;
+    /**
+     * Sets the locale for this command.
+     * @param locale The locale to set.
+     */
+    setLocale(locale: Locale | null): void;
+    /**
+     * Returns the i18n api for this command.
+     * @param locale The locale to use for the i18n api.
+     */
+    locale(locale?: Locale): Localization;
+    /**
+     * Creates a clone of this context
+     */
+    clone(config?: Partial<ContextParameters<ExecutionMode>>): Context<ExecutionMode>;
+    isMiddleware(): this is MiddlewareContext<ExecutionMode>;
+    args(): string[];
+}
+declare class MiddlewareContext<T extends CommandExecutionMode> extends Context<T> {
+    #private;
+    /**
+     * Whether the command execution was cancelled.
+     */
+    get cancelled(): boolean;
+    /**
+     * Cancels the command execution.
+     */
+    cancel(): void;
+}
+
+interface AppCommand {
+    command: SlashCommandBuilder | Record<string, any>;
+    chatInput?: (ctx: Context) => Awaitable<unknown>;
+    autocomplete?: (ctx: Context) => Awaitable<unknown>;
+    message?: (ctx: Context) => Awaitable<unknown>;
+    messageContextMenu?: (ctx: Context) => Awaitable<unknown>;
+    userContextMenu?: (ctx: Context) => Awaitable<unknown>;
+}
+interface AppCommandMiddleware {
+    beforeExecute: (ctx: Context) => Awaitable<unknown>;
+    afterExecute: (ctx: Context) => Awaitable<unknown>;
+}
+interface LoadedCommand {
+    command: ParsedCommand;
+    data: AppCommand;
+}
+interface LoadedMiddleware {
+    middleware: ParsedMiddleware;
+    data: AppCommandMiddleware;
+}
+interface PreparedAppCommandExecution {
+    command: LoadedCommand;
+    middlewares: LoadedMiddleware[];
+    messageCommandParser?: MessageCommandParser;
+}
+type CommandBuilderLike = SlashCommandBuilder | ContextMenuCommandBuilder | Record<string, any>;
+declare class AppCommandHandler {
+    readonly commandkit: CommandKit;
+    private loadedCommands;
+    private loadedMiddlewares;
+    constructor(commandkit: CommandKit);
+    getCommandsArray(): any[];
+    prepareCommandRun(source: Interaction | Message): Promise<PreparedAppCommandExecution | null>;
+    loadCommands(): Promise<void>;
+    applyLocalizations(command: CommandBuilderLike): Promise<discord_js.RESTPostAPIContextMenuApplicationCommandsJSONBody | CommandBuilderLike>;
+}
+
+interface CommandKitConfiguration {
+    defaultLocale: Locale;
+    localizationStrategy: LocalizationStrategy;
+    getMessageCommandPrefix: (message: Message) => Awaitable<string | string[]>;
+}
 declare class CommandKit extends EventEmitter {
     #private;
     readonly eventInterceptor: EventInterceptor;
     static readonly createElement: typeof createElement;
     static readonly Fragment: typeof Fragment;
+    readonly config: CommandKitConfiguration;
+    commandsRouter: CommandsRouter;
+    eventsRouter: EventsRouter;
+    appCommandsHandler: AppCommandHandler;
     static instance: CommandKit | undefined;
     /**
      * Create a new command and event handler with CommandKit.
@@ -658,6 +1364,21 @@ declare class CommandKit extends EventEmitter {
      * @see {@link https://commandkit.js.org/docs/guide/commandkit-setup}
      */
     constructor(options: CommandKitOptions);
+    /**
+     * Sets the prefix resolver for the command handler.
+     * @param resolver The resolver function.
+     */
+    setPrefixResolver(resolver: (message: Message) => Awaitable<string | string[]>): this;
+    /**
+     * Sets the default locale for the command handler.
+     * @param locale The default locale.
+     */
+    setDefaultLocale(locale: Locale): this;
+    /**
+     * Sets the localization strategy for the command handler.
+     * @param strategy The localization strategy.
+     */
+    setLocalizationStrategy(strategy: LocalizationStrategy): this;
     /**
      * Resolves the current cache provider.
      */
@@ -722,6 +1443,14 @@ declare class CommandKit extends EventEmitter {
      * Decrement the client listeners count.
      */
     decrementClientListenersCount(): void;
+    /**
+     * Path to the app directory. Returns `null` if not found.
+     * The lookup order is:
+     * - `./app`
+     * - `./src/app`
+     */
+    getAppDirectory(): string | null;
+    getPath(to: 'locales' | 'commands' | 'events'): string | null;
 }
 
 interface CommandKitConfig {
@@ -776,146 +1505,6 @@ type R = (typeof requiredProps)[number];
 type PartialConfig<T extends CommandKitConfig> = Partial<Omit<T, R>> & Pick<T, R>;
 declare function defineConfig(config: PartialConfig<CommandKitConfig>): Partial<CommandKitConfig>;
 
-interface CommandKitEnvironmentInternalData {
-    executionError: Error | null;
-    type: CommandKitEnvironmentType | null;
-    variables: Map<string, any>;
-    deferredFunctions: Map<string, GenericFunction<[CommandKitEnvironment]>>;
-    marker: string;
-    markStart: number;
-    markEnd: number;
-}
-declare class CommandKitEnvironment {
-    #private;
-    readonly commandkit: CommandKit;
-    /**
-     * Creates the commandkit execution environment.
-     * @param commandkit - The commandkit instance.
-     */
-    constructor(commandkit: CommandKit);
-    /**
-     * Get the execution error.
-     * @internal
-     */
-    getExecutionError(): Error | null;
-    /**
-     * Set the execution error.
-     * @param error - The error to set.
-     * @internal
-     */
-    setExecutionError(error: Error): void;
-    /**
-     * Get the environment type.
-     */
-    getType(): CommandKitEnvironmentType;
-    /**
-     * Set the environment type.
-     * @param type - The environment type to set.
-     * @internal
-     */
-    setType(type: CommandKitEnvironmentType): void;
-    /**
-     * The variables store for this environment.
-     */
-    get variables(): Map<string, any>;
-    /**
-     * Register a deferred function.
-     * @param fn - The deferred function to register.
-     * @returns The deferred function id.
-     * @internal
-     */
-    registerDeferredFunction(fn: GenericFunction<[CommandKitEnvironment]>): string;
-    /**
-     * Clear a deferred function by id.
-     * @param id - The deferred function id to clear.
-     * @internal
-     */
-    clearDeferredFunction(id: string): void;
-    /**
-     * Run all deferred functions sequentially.
-     * @internal
-     */
-    runDeferredFunctions(): Promise<void>;
-    /**
-     * Clear all deferred functions.
-     * @internal
-     */
-    clearAllDeferredFunctions(): void;
-    /**
-     * Mark the start of a command execution.
-     * @param marker - The marker to set.
-     * @internal
-     */
-    markStart(marker: string): void;
-    /**
-     * Mark the end of a command execution.
-     * @internal
-     */
-    markEnd(): void;
-    /**
-     * Get the marker.
-     * @internal
-     */
-    getMarker(): string;
-    /**
-     * Get the execution time in milliseconds.
-     * @internal
-     */
-    getExecutionTime(): number;
-}
-declare enum CommandKitEnvironmentType {
-    CommandHandler = "COMMAND_HANDLER"
-}
-/**
- * Runs the given function after the current handler has finished executing.
- * @param fn The function to run after the current handler.
- * @returns The deferred function id. This can be used to cancel the deferred function.
- */
-declare function after(fn: GenericFunction<[CommandKitEnvironment]>): string;
-/**
- * Cancels a deferred function registered with `after`.
- * @param id The deferred function id to cancel.
- */
-declare function cancelAfter(id: string): void;
-
-type GenericFunction<A extends any[] = any[]> = (...args: A) => any;
-declare function exitContext<T>(fn: () => T): T;
-/**
- * Returns a context-aware version of the given function.
- * @param env - The commandkit environment data.
- * @param fn - The target function.
- * @param finalizer - An optional finalizer function to run after the target function. This function will be context-aware.
- * @internal
- */
-declare function makeContextAwareFunction<R extends GenericFunction, F extends GenericFunction>(env: CommandKitEnvironment, fn: R, finalizer?: F): R;
-/**
- * Retrieves commandkit
- * @private
- * @internal
- */
-declare function getCommandKit(): CommandKit | undefined;
-declare function getCommandKit(strict: true): CommandKit;
-declare function getCommandKit(strict: false): CommandKit | undefined;
-/**
- * Get the current commandkit context.
- * @internal
- */
-declare function getContext(): CommandKitEnvironment | void;
-/**
- * Use current commandkit context. Throws an error if no context is found.
- */
-declare function useEnvironment(): CommandKitEnvironment;
-/**
- * Ensures the command is only available in guilds.
- * Note: do not wrap this function in a try/catch block.
- */
-declare function guildOnly(): void;
-/**
- * Ensures the command is only available in DMs.
- * Note: do not wrap this function in a try/catch block.
- */
-declare function dmOnly(): void;
-
 declare class MemoryCache extends CacheProvider {
     #private;
     get<T>(key: string): Promise<CacheEntry<T> | undefined>;
@@ -979,6 +1568,30 @@ declare function invalidate(tag: string): Promise<void>;
  */
 declare function revalidate<R = any>(tag: string, ...args: any[]): Promise<R | undefined>;
 
+declare class DefaultLocalizationStrategy implements LocalizationStrategy {
+    private readonly commandkit;
+    private translations;
+    constructor(commandkit: CommandKit);
+    locateTranslation(scope: string, locale: Locale): Promise<Translation | null>;
+    getTranslationStrict(scope: string, locale: Locale): Promise<Translation>;
+    getTranslation(scope: string, locale: Locale): Promise<Translation | null>;
+    translate(request: LocalizationTranslationRequest): Promise<TranslationResult>;
+    private applyTranslation;
+}
+
+/**
+ * Cancel upcoming middleware execution.
+ * If this is called inside pre-stage middleware, the next run will be the actual command, skipping all other pre-stage middlewares.
+ * If this is called inside a command itself, it will skip all post-stage middlewares.
+ * If this is called inside post-stage middleware, it will skip all other post-stage middlewares.
+ */
+declare function exitMiddleware(): never;
+/**
+ * Rethrow the error if it is a CommandKit error.
+ * @param error The error to rethrow.
+ */
+declare function rethrow(error: unknown): void;
+
 /**
  * Creates a command line interface for CommandKit.
  * @param argv The arguments passed to the CLI.
@@ -991,4 +1604,4 @@ declare function bootstrapCommandkitCLI(argv: string[], options?: commander.Pars
  */
 declare const version: string;
 
-export { ActionRow, type ActionRowProps, type AnyCommandKitElement, type AsyncFunction, type AutocompleteProps, Button, type ButtonChildrenLike, ButtonKit, type ButtonKitPredicate, type ButtonProps, type CacheEntry, type CacheParams, CacheProvider, type CacheTag, type CommandContext, type CommandData, type CommandFileObject, CommandKit, type CommandKitButtonBuilderInteractionCollectorDispatch, type CommandKitButtonBuilderInteractionCollectorDispatchContextData, type CommandKitButtonBuilderOnEnd, type CommandKitConfig, type CommandKitData, type CommandKitElement, type CommandKitElementData, CommandKitEnvironment, type CommandKitEnvironmentInternalData, CommandKitEnvironmentType, type CommandKitModalBuilderInteractionCollectorDispatch, type CommandKitModalBuilderInteractionCollectorDispatchContextData, type CommandKitModalBuilderOnEnd, type CommandKitOptions, type CommandObject, type CommandOptions, type CommandProps, type ContextMenuCommandProps, ElementType, EventInterceptor, type EventInterceptorContextData, Fragment, type FragmentElementProps, type GenericFunction, type MaybeArray, MemoryCache, type MessageContextMenuCommandProps, Modal, ModalKit, type ModalKitPredicate, type ModalProps, type OnButtonKitClick, type OnButtonKitEnd, type OnModalKitEnd, type OnModalKitSubmit, ParagraphInput, type ReloadOptions, ReloadType, ShortInput, type SlashCommandProps, TextInput, type TextInputProps, type UserContextMenuCommandProps, type ValidationProps, after, bootstrapCommandkitCLI, cache, cacheLife, cacheTag, cancelAfter, createElement, CommandKit as default, defineConfig, dmOnly, exitContext, getCommandKit, getConfig, getContext, getElement, guildOnly, invalidate, isCommandKitElement, makeContextAwareFunction, 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 AnyCommandKitElement, AppCommandHandler, type AsyncFunction, type AutocompleteCommandContext, type AutocompleteCommandMiddlewareContext, type AutocompleteProps, Button, type ButtonChildrenLike, ButtonKit, type ButtonKitPredicate, type ButtonProps, type CacheEntry, type CacheParams, CacheProvider, type CacheTag, type CommandContext, type CommandContextOptions, type CommandData, CommandExecutionMode, type CommandFileObject, CommandKit, type CommandKitButtonBuilderInteractionCollectorDispatch, type CommandKitButtonBuilderInteractionCollectorDispatchContextData, type CommandKitButtonBuilderOnEnd, type CommandKitConfig, type CommandKitConfiguration, type CommandKitData, type CommandKitElement, type CommandKitElementData, CommandKitEnvironment, type CommandKitEnvironmentInternalData, CommandKitEnvironmentType, type CommandKitModalBuilderInteractionCollectorDispatch, type CommandKitModalBuilderInteractionCollectorDispatchContextData, type CommandKitModalBuilderOnEnd, type CommandKitOptions, type CommandObject, type CommandOptions, type CommandProps, Context, type ContextMenuCommandProps, type ContextParameters, DefaultLocalizationStrategy, ElementType, EventInterceptor, type EventInterceptorContextData, type EventInterceptorErrorHandler, Fragment, type FragmentElementProps, type GenericFunction, type InteractionCommandContext, type InteractionCommandMiddlewareContext, Localization, type LocalizationConfig, type LocalizationStrategy, type LocalizationTranslationRequest, type MaybeArray, MemoryCache, type MessageCommandContext, type MessageCommandMiddlewareContext, MessageCommandOptions, type MessageCommandOptionsSchema, MessageCommandParser, type MessageContextMenuCommandContext, type MessageContextMenuCommandMiddlewareContext, type MessageContextMenuCommandProps, MiddlewareContext, Modal, ModalKit, type ModalKitPredicate, type ModalProps, type OnButtonKitClick, type OnButtonKitEnd, type OnModalKitEnd, type OnModalKitSubmit, ParagraphInput, type ParsedMessageCommand, type PreparedAppCommandExecution, type ReloadOptions, ReloadType, ShortInput, type SlashCommandContext, type SlashCommandMiddlewareContext, type SlashCommandProps, TextInput, type TextInputProps, type TranslatableArguments, type TranslatableCommand, type TranslatableCommandOptions, type Translation, type TranslationResult, type Translator, type UserContextMenuCommandContext, type UserContextMenuCommandMiddlewareContext, type UserContextMenuCommandProps, type ValidationProps, afterCommand, bootstrapCommandkitCLI, cache, cacheLife, cacheTag, cancelAfterCommand, createElement, CommandKit as default, defineConfig, dmOnly, exitContext, exitMiddleware, getCommandKit, getConfig, getContext, getElement, guildOnly, invalidate, isCommandKitElement, makeContextAwareFunction, 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 };