commandkit 0.1.11-dev.20250208091524 → 0.1.11-dev.20250208131735

package/dist/index.d.mts

@@ -1,28 +1,994 @@
-import { C as CommandKit } from './CommandKit-Cu0lwE15.mjs';
-export { A as AutocompleteProps, c as CommandContext, h as CommandData, d as CommandFileObject, b as CommandKitData, a as CommandKitOptions, i as CommandObject, g as CommandOptions, e as CommandProps, f as ContextMenuCommandProps, M as MessageContextMenuCommandProps, R as ReloadOptions, j as ReloadType, S as SlashCommandProps, U as UserContextMenuCommandProps, V as ValidationProps } from './CommandKit-Cu0lwE15.mjs';
-export { ActionRow, ActionRowProps } from './components/action-row/ActionRow.mjs';
-export { ButtonKit, ButtonKitPredicate, CommandKitButtonBuilderInteractionCollectorDispatch, CommandKitButtonBuilderInteractionCollectorDispatchContextData, CommandKitButtonBuilderOnEnd, OnButtonKitClick, OnButtonKitEnd } from './components/button/ButtonKit.mjs';
-export { Button, ButtonChildrenLike, ButtonProps } from './components/button/Button.mjs';
-export { CommandKitModalBuilderInteractionCollectorDispatch, CommandKitModalBuilderInteractionCollectorDispatchContextData, CommandKitModalBuilderOnEnd, ModalKit, ModalKitPredicate, OnModalKitEnd, OnModalKitSubmit } from './components/modal/ModalKit.mjs';
-export { Modal, ModalProps, ParagraphInput, ShortInput, TextInput, TextInputProps } from './components/modal/Modal.mjs';
-export { AnyCommandKitElement, CommandKitElement, CommandKitElementData, ElementType, Fragment, FragmentElementProps, createElement, getElement, isCommandKitElement } from './components/common/element.mjs';
-export { MaybeArray } from './components/common/types.mjs';
-export { EventInterceptor, EventInterceptorContextData } from './components/common/EventInterceptor.mjs';
-export { CommandKitConfig, defineConfig, getConfig } from './config.mjs';
-export { c as CommandKitEnvironment, C as CommandKitEnvironmentInternalData, f as CommandKitEnvironmentType, G as GenericFunction, h as after, i as cancelAfter, d as dmOnly, e as exitContext, g as getCommandKit, a as getContext, b as guildOnly, m as makeContextAwareFunction, u as useEnvironment } from './async-context-JOhTuMRX.mjs';
-export { CacheEntry, CacheProvider } from './cache/CacheProvider.mjs';
-export { MemoryCache } from './cache/MemoryCache.mjs';
-export { AsyncFunction, CacheParams, CacheTag, cache, cacheLife, cacheTag, invalidate, revalidate, 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 } from './cache/cache.mjs';
-export { bootstrapCommandkitCLI } from './cli/init.mjs';
-import './handlers/validation-handler/ValidationHandler.mjs';
-import './handlers/validation-handler/typings.mjs';
-import 'discord.js';
-import 'node:events';
-import 'commander';
+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 EventEmitter from 'node:events';
+import * as commander from 'commander';
+
+interface CacheEntry<T = unknown> {
+    value: T;
+    ttl?: number;
+}
+declare abstract class CacheProvider {
+    abstract get<T>(key: string): Promise<CacheEntry<T> | undefined>;
+    abstract set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    abstract exists(key: string): Promise<boolean>;
+    abstract delete(key: string): Promise<void>;
+    abstract clear(): Promise<void>;
+    abstract expire(key: string, ttl: number): Promise<void>;
+}
+
+/**
+ * Options for instantiating a CommandKit handler.
+ */
+interface CommandKitOptions {
+    /**
+     * The Discord.js client object to use with CommandKit.
+     */
+    client: Client;
+    /**
+     * The path to your commands directory.
+     */
+    commandsPath?: string;
+    /**
+     * The path to your events directory.
+     */
+    eventsPath?: string;
+    /**
+     * The path to the validations directory.
+     */
+    validationsPath?: string;
+    /**
+     * List of development guild IDs to restrict devOnly commands to.
+     */
+    devGuildIds?: string[];
+    /**
+     * List of developer user IDs to restrict devOnly commands to.
+     */
+    devUserIds?: string[];
+    /**
+     * List of developer role IDs to restrict devOnly commands to.
+     */
+    devRoleIds?: string[];
+    /**
+     * Skip CommandKit's built-in validations (for devOnly commands).
+     */
+    skipBuiltInValidations?: boolean;
+    /**
+     * Bulk register application commands instead of one-by-one.
+     */
+    bulkRegister?: boolean;
+    /**
+     * Whether or not to debug the command handler.
+     */
+    debugCommands?: boolean;
+    /**
+     * The cache provider to use with CommandKit. Defaults to MemoryCache provider.
+     * Set this to `null` to not use any cache provider.
+     */
+    cacheProvider?: CacheProvider | null;
+}
+/**
+ * Private data for the CommandKit class.
+ */
+interface CommandKitData extends CommandKitOptions {
+    commandHandler?: CommandHandler;
+    eventHandler?: EventHandler;
+    validationHandler?: ValidationHandler;
+}
+/**
+ * Represents a command context.
+ */
+interface CommandContext<T extends Interaction, Cached extends CacheType> {
+    /**
+     * The interaction that triggered this command.
+     */
+    interaction: Interaction<CacheType>;
+    /**
+     * The client that instantiated this command.
+     */
+    client: Client;
+    /**
+     * The command data.
+     */
+    handler: CommandKit;
+}
+/**
+ * Represents a command file.
+ */
+interface CommandFileObject {
+    data: CommandData;
+    options?: CommandOptions;
+    run: <Cached extends CacheType = CacheType>(ctx: CommandContext<Interaction, Cached>) => Awaited<void>;
+    autocomplete?: <Cached extends CacheType = CacheType>(ctx: CommandContext<Interaction, Cached>) => Awaited<void>;
+    filePath: string;
+    category: string | null;
+    [key: string]: any;
+}
+/**
+ * A reload type for commands.
+ */
+type ReloadOptions = 'dev' | 'global' | ReloadType;
+/**
+ * Props for command run functions.
+ */
+interface CommandProps {
+    /**
+     * The current command interaction object.
+     */
+    interaction: ChatInputCommandInteraction | ContextMenuCommandInteraction | UserContextMenuCommandInteraction | MessageContextMenuCommandInteraction | AutocompleteInteraction;
+    /**
+     * The Discord.js client object that CommandKit is handling.
+     */
+    client: Client<true>;
+    /**
+     * The current CommandKit handler instance.
+     */
+    handler: CommandKit;
+}
+/**
+ * Props for autocomplete command run functions.
+ */
+interface AutocompleteProps extends CommandProps {
+    /**
+     * The current autocomplete command interaction object.
+     */
+    interaction: AutocompleteInteraction;
+}
+/**
+ * Props for slash (chat input) command run functions.
+ */
+interface SlashCommandProps extends CommandProps {
+    /**
+     * The current slash (chat input) command interaction object.
+     */
+    interaction: ChatInputCommandInteraction;
+}
+/**
+ * Props for context menu command run functions.
+ */
+interface ContextMenuCommandProps extends CommandProps {
+    /**
+     * The current context menu command interaction object.
+     */
+    interaction: ContextMenuCommandInteraction;
+}
+/**
+ * Props for user context menu command run functions.
+ */
+interface UserContextMenuCommandProps extends CommandProps {
+    interaction: UserContextMenuCommandInteraction;
+}
+/**
+ * Props for message context menu command run functions.
+ */
+interface MessageContextMenuCommandProps extends CommandProps {
+    interaction: MessageContextMenuCommandInteraction;
+}
+/**
+ * Props for command validation functions.
+ */
+interface ValidationProps {
+    /**
+     * The current command interaction object.
+     */
+    interaction: ChatInputCommandInteraction | ContextMenuCommandInteraction | AutocompleteInteraction;
+    /**
+     * The Discord.js client object that CommandKit is handling.
+     */
+    client: Client<true>;
+    /**
+     * The current (local) target command object.
+     */
+    commandObj: CommandObject;
+    /**
+     * The current CommandKit handler instance.
+     */
+    handler: CommandKit;
+}
+/**
+ * Additional command configuration options.
+ */
+interface CommandOptions {
+    /**
+     * A boolean indicating whether the command is guild-only.
+     * Used for built-in validation.
+     *
+     * @deprecated Use `dm_permission` in the command's `data` object instead.
+     */
+    guildOnly?: boolean;
+    /**
+     * A boolean indicating whether the command is developer-only.
+     * Used for registration and built-in validation.
+     */
+    devOnly?: boolean;
+    /**
+     * A boolean indicating whether the command is deleted/ignored on restart/reload.
+     */
+    deleted?: boolean;
+    /**
+     * A string or array of permissions that a user needs for the current command to be executed.
+     * Used for built-in validation.
+     *
+     * @example
+     * userPermissions: 'BanMembers'
+     * or
+     * userPermissions: ['BanMembers', 'KickMembers']
+     */
+    userPermissions?: PermissionsString | PermissionsString[];
+    /**
+     * A string or array of permissions that the bot needs to execute the current command.
+     * Used for built-in validation.
+     *
+     * @example
+     * botPermissions: 'BanMembers'
+     * or
+     * botPermissions: ['BanMembers', 'KickMembers']
+     */
+    botPermissions?: PermissionsString | PermissionsString[];
+    [key: string]: any;
+}
+type CommandData = RESTPostAPIApplicationCommandsJSONBody;
+type CommandObject = {
+    /**
+     * An object which defines the structure of the application command.
+     */
+    data: CommandData;
+    /**
+     * Additional command configuration options.
+     */
+    options?: CommandOptions;
+    /**
+     * The path to the command file.
+     */
+    filePath: string;
+    /**
+     * The command's category. Determined based on the command folder.
+     *
+     * @example
+     * ```txt
+     * "/src/commands/ping.js" -> null
+     * "/src/commands/Misc/ping.js" -> "Misc"
+     * ```
+     */
+    category: string | null;
+    [key: string]: any;
+};
+declare enum ReloadType {
+    /**
+     * Reload developer/guild commands.
+     */
+    Developer = "dev",
+    /**
+     * Reload global commands.
+     */
+    Global = "global"
+}
+
+/**
+ * Validation handler options (validationsPath).
+ */
+interface ValidationHandlerOptions {
+    validationsPath: string;
+}
+
+/**
+ * A handler for command validations.
+ */
+declare class ValidationHandler {
+    #private;
+    constructor({ ...options }: ValidationHandlerOptions);
+    init(): Promise<void>;
+    get validations(): Function[];
+    reloadValidations(): Promise<void>;
+}
+
+/**
+ * Command handler options.
+ * Similar to CommandKit options in structure.
+ */
+interface CommandHandlerOptions {
+    /**
+     * The client created by the user.
+     */
+    client: Client;
+    /**
+     * Path to the user's commands.
+     */
+    commandsPath: string;
+    /**
+     * An array of developer guild IDs.
+     */
+    devGuildIds: string[];
+    /**
+     * An array of developer user IDs.
+     */
+    devUserIds: string[];
+    /**
+     * An array of developer role IDs.
+     */
+    devRoleIds: string[];
+    /**
+     * A validation handler instance to run validations before commands.
+     */
+    validationHandler?: ValidationHandler;
+    /**
+     * A boolean indicating whether to skip CommandKit's built-in validations (permission checking, etc.)
+     */
+    skipBuiltInValidations: boolean;
+    /**
+     * The CommandKit handler that instantiated this.
+     */
+    commandkitInstance: CommandKit;
+    /**
+     * A boolean indicating whether to register all commands in bulk.
+     */
+    bulkRegister: boolean;
+}
+
+/**
+ * A handler for client application commands.
+ */
+declare class CommandHandler {
+    #private;
+    constructor({ ...options }: CommandHandlerOptions);
+    init(): Promise<void>;
+    handleCommands(): void;
+    get commands(): CommandFileObject[];
+    reloadCommands(type?: ReloadOptions): Promise<void>;
+}
+
+/**
+ * Event handler options.
+ */
+interface EventHandlerOptions {
+    client: Client;
+    eventsPath: string;
+    commandKitInstance: CommandKit;
+}
+
+/**
+ * A handler for client events.
+ */
+declare class EventHandler {
+    #private;
+    constructor({ ...options }: EventHandlerOptions);
+    init(): Promise<void>;
+    get events(): {
+        name: string;
+        functions: Function[];
+    }[];
+    reloadEvents(commandHandler?: CommandHandler): Promise<void>;
+}
+
+interface EventInterceptorContextData<E extends keyof ClientEvents> {
+    /**
+     * The filter to use for the collector.
+     */
+    filter?: (...args: ClientEvents[E]) => Awaitable<boolean>;
+    /**
+     * The duration (in ms) that the collector should run for.
+     */
+    time?: number;
+    /**
+     * If the collector should automatically reset the timer when a button is clicked.
+     */
+    autoReset?: boolean;
+    /**
+     * The handler to run when the collector ends.
+     */
+    onEnd?: (reason: string) => Awaitable<void>;
+}
+declare class EventInterceptor {
+    #private;
+    readonly client: Client;
+    private subscribers;
+    private globalHandlers;
+    private cleanupTimer;
+    /**
+     * Creates the event interceptor.
+     */
+    constructor(client: Client);
+    /**
+     * Destroys the event interceptor.
+     */
+    destroy(): void;
+    /**
+     * Whether the event has subscribers.
+     * @param event The event to check.
+     */
+    hasSubscribers(event: keyof ClientEvents): boolean;
+    /**
+     * Returns the number of subscribers for the event.
+     * @param event The event to check.
+     */
+    getSubscriberCount(event: keyof ClientEvents): number;
+    /**
+     * Whether the event has global handlers.
+     */
+    hasGlobalHandlers(): boolean;
+    /**
+     * Returns the number of global handlers.
+     */
+    getGlobalHandlersCount(): number;
+    /**
+     * Subscribes to an event.
+     * @param event The event to subscribe to.
+     * @param listener The listener to call when the event is emitted.
+     * @returns A function to unsubscribe from the event.
+     */
+    subscribe<Event extends keyof ClientEvents>(event: Event, listener: (...args: ClientEvents[Event]) => void, options?: EventInterceptorContextData<Event>): () => void;
+    /**
+     * Unsubscribes from an event.
+     * @param event The event to unsubscribe from.
+     */
+    unsubscribe<Event extends keyof ClientEvents>(event: Event, listener: (...args: ClientEvents[Event]) => void, reason?: string): void;
+    /**
+     * Creates a global handler for the event.
+     * @param event The event to create a global handler for.
+     * @returns The global handler.
+     */
+    private createGlobalHandler;
+}
+
+type ButtonKitPredicate = (interaction: ButtonInteraction) => Awaitable<boolean>;
+/**
+ * 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 OnButtonKitClick = CommandKitButtonBuilderInteractionCollectorDispatch;
+/**
+ * The handler to run when the interaction collector ends. This handler is called with the reason as the first argument.
+ * If the first argument is null, it means that the interaction collector has been destroyed.
+ */
+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 CommandKitButtonBuilderOnEnd = (reason: string) => Awaitable<void>;
+type CommandKitButtonBuilderInteractionCollectorDispatchContextData = EventInterceptorContextData<Events.InteractionCreate>;
+declare class ButtonKit extends ButtonBuilder {
+    #private;
+    /**
+     * Sets up an inline interaction collector for this button. This collector by default allows as many interactions as possible if it is actively used.
+     * If unused, this expires after 24 hours or custom time if specified.
+     * @param handler The handler to run when the button is clicked
+     * @param data The context data to use for the interaction collector
+     * @returns This button
+     * @example
+     * ```ts
+     * const button = new ButtonKit()
+     *   .setLabel('Click me')
+     *   .setStyle(ButtonStyle.Primary)
+     *   .setCustomId('click_me')
+     *   .filter((interaction) => interaction.user.id === '1234567890')
+     *   .onClick(async (interaction) => {
+     *     await interaction.reply('You clicked me!');
+     *   });
+     *
+     * const row = new ActionRowBuilder().addComponents(button);
+     *
+     * const message = await channel.send({ content: 'Click the button', components: [row] });
+     *
+     * // Remove onClick handler and destroy the interaction collector
+     * button.onClick(null);
+     * ```
+     */
+    onClick(handler: CommandKitButtonBuilderInteractionCollectorDispatch, data?: CommandKitButtonBuilderInteractionCollectorDispatchContextData): this;
+    onEnd(handler: CommandKitButtonBuilderOnEnd): this;
+    /**
+     * Sets a filter for the interaction collector.
+     * @param predicate The filter to use for the interaction collector
+     */
+    filter(predicate: ButtonKitPredicate): this;
+    private get customId();
+    dispose(): this;
+}
+
+type ModalKitPredicate = (interaction: ModalSubmitInteraction) => Awaitable<boolean>;
+/**
+ * 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 OnModalKitSubmit = CommandKitModalBuilderInteractionCollectorDispatch;
+/**
+ * The handler to run when the interaction collector ends. This handler is called with the reason as the first argument.
+ * If the first argument is null, it means that the interaction collector has been destroyed.
+ */
+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 CommandKitModalBuilderOnEnd = (reason: string) => Awaitable<void>;
+type CommandKitModalBuilderInteractionCollectorDispatchContextData = EventInterceptorContextData<Events.InteractionCreate>;
+declare class ModalKit extends ModalBuilder {
+    #private;
+    /**
+     * Sets the handler to run when the modal is submitted.
+     * @param handler - The handler to run when the modal is submitted.
+     * @param data - The context data for the interaction collector.
+     * @returns This instance of the modal builder.
+     * @example
+     * ```ts
+     * const modal = new ModalKit()
+     *  .setTitle('My Modal')
+     *  .setCustomId('my-modal')
+     *  .filter((interaction) => interaction.user.id === '1234567890')
+     *  .onSubmit(async (interaction) => {
+     *     await interaction.reply('You submitted the modal!');
+     *   })
+     *   .addComponents(actionRow1, actionRow2);
+     * ```
+     */
+    onSubmit(handler: CommandKitModalBuilderInteractionCollectorDispatch, data?: CommandKitModalBuilderInteractionCollectorDispatchContextData): 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.
+     */
+    onEnd(handler: CommandKitModalBuilderOnEnd): this;
+    /**
+     * Sets a filter for the interaction collector.
+     * @param predicate - The filter to use for the interaction collector.
+     * @returns This instance of the modal builder.
+     */
+    filter(predicate: ModalKitPredicate): this;
+    private get customId();
+    dispose(): this;
+}
+
+declare const ElementType: {
+    readonly ActionRow: "action-row";
+    readonly Button: "button-kit";
+    readonly Modal: "modal";
+    readonly TextInput: "text-input";
+};
+type ElementType = (typeof ElementType)[keyof typeof ElementType];
+interface CommandKitElementData {
+    [ElementType.ActionRow]: ActionRowBuilder;
+    [ElementType.Button]: ButtonKit;
+    [ElementType.Modal]: ModalKit;
+    [ElementType.TextInput]: TextInputBuilder;
+}
+type CommandKitElement<Type extends ElementType> = CommandKitElementData[Type];
+type AnyCommandKitElement = CommandKitElement<ElementType>;
+declare function isCommandKitElement(element: unknown): element is CommandKitElement<ElementType>;
+declare function getElement<T extends ElementType, E extends CommandKitElement<T>>(element: E): CommandKitElementData[T];
+interface FragmentElementProps {
+    children: [];
+}
+declare function Fragment(props: FragmentElementProps): CommandKitElementData[ElementType][];
+declare function createElement(type: Function, props: Record<string, unknown>, ...children: any[]): CommandKitElement<ElementType>;
+
+interface ActionRowProps {
+    children?: AnyCommandKitElement[] | AnyCommandKitElement;
+}
+/**
+ * The action row component.
+ * @param props The action row properties.
+ * @returns The commandkit element.
+ * @example <ActionRow><Button label="Click me" style={ButtonStyle.Primary} customId="click_me" /></ActionRow>
+ */
+declare function ActionRow(props: ActionRowProps): CommandKitElement<'action-row'>;
+
+type MaybeArray<T> = T | T[];
+
+type ButtonChildrenLike = string | number | boolean;
+interface ButtonProps {
+    label?: string;
+    style?: ButtonStyle;
+    emoji?: ComponentEmojiResolvable;
+    disabled?: boolean;
+    customId?: string;
+    url?: string;
+    skuId?: string;
+    onClick?: CommandKitButtonBuilderInteractionCollectorDispatch;
+    options?: CommandKitButtonBuilderInteractionCollectorDispatchContextData;
+    onEnd?: CommandKitButtonBuilderOnEnd;
+    children?: MaybeArray<ButtonChildrenLike>;
+}
+/**
+ * The button component.
+ * @param props The button properties.
+ * @returns The commandkit element.
+ * @example <Button style={ButtonStyle.Primary} customId="click_me">Click Me</Button>
+ */
+declare function Button(props: ButtonProps): CommandKitElement<'button-kit'>;
+
+interface ModalProps {
+    customId?: string;
+    title: string;
+    children?: MaybeArray<TextInputBuilder | ActionRowBuilder>;
+    onSubmit?: OnModalKitSubmit;
+    onEnd?: OnModalKitEnd;
+    options?: CommandKitModalBuilderInteractionCollectorDispatchContextData;
+}
+/**
+ * The modal component.
+ * @param props The modal properties.
+ * @returns The commandkit element.
+ * @example <Modal title="My Modal" onSubmit={onSubmit}>...</Modal>
+ */
+declare function Modal(props: ModalProps): CommandKitElement<'modal'>;
+interface TextInputProps {
+    customId: string;
+    label: string;
+    placeholder?: string;
+    maxLength?: number;
+    minLength?: number;
+    value?: string;
+    required?: boolean;
+}
+/**
+ * The text input component.
+ * @param props The text input properties.
+ * @returns The commandkit element.
+ * @example <TextInput customId="input" label="Input" style={TextInputStyle.Short} />
+ */
+declare function TextInput(props: TextInputProps & {
+    style: TextInputStyle;
+}): CommandKitElement<'text-input'>;
+/**
+ * The short text input component.
+ * @param props The text input properties.
+ * @returns The commandkit element.
+ * @example <ShortInput customId="input" label="Input" />
+ */
+declare function ShortInput(props: TextInputProps): CommandKitElement<'text-input'>;
+/**
+ * The paragraph text input component.
+ * @param props The text input properties.
+ * @returns The commandkit element.
+ * @example <ParagraphInput customId="input" label="Input" />
+ */
+declare function ParagraphInput(props: TextInputProps): CommandKitElement<'text-input'>;
+
+declare class CommandKit extends EventEmitter {
+    #private;
+    readonly eventInterceptor: EventInterceptor;
+    static readonly createElement: typeof createElement;
+    static readonly Fragment: typeof Fragment;
+    static instance: CommandKit | undefined;
+    /**
+     * Create a new command and event handler with CommandKit.
+     *
+     * @param options - The default CommandKit configuration.
+     * @see {@link https://commandkit.js.org/docs/guide/commandkit-setup}
+     */
+    constructor(options: CommandKitOptions);
+    /**
+     * Resolves the current cache provider.
+     */
+    getCacheProvider(): CacheProvider | null;
+    /**
+     * Whether or not to debug the command handler.
+     */
+    isDebuggingCommands(): boolean;
+    /**
+     * Get the client attached to this CommandKit instance.
+     */
+    get client(): discord_js.Client<boolean>;
+    /**
+     * Get command handler instance.
+     */
+    get commandHandler(): CommandHandler | undefined;
+    /**
+     * Updates application commands with the latest from "commandsPath".
+     */
+    reloadCommands(type?: ReloadOptions): Promise<void>;
+    /**
+     * Updates application events with the latest from "eventsPath".
+     */
+    reloadEvents(): Promise<void>;
+    /**
+     * Updates application command validations with the latest from "validationsPath".
+     */
+    reloadValidations(): Promise<void>;
+    /**
+     * @returns An array of objects of all the commands that CommandKit is handling.
+     */
+    get commands(): CommandObject[];
+    /**
+     * @returns The path to the commands folder which was set when instantiating CommandKit.
+     */
+    get commandsPath(): string | undefined;
+    /**
+     * @returns The path to the events folder which was set when instantiating CommandKit.
+     */
+    get eventsPath(): string | undefined;
+    /**
+     * @returns The path to the validations folder which was set when instantiating CommandKit.
+     */
+    get validationsPath(): string | undefined;
+    /**
+     * @returns An array of all the developer user IDs which was set when instantiating CommandKit.
+     */
+    get devUserIds(): string[];
+    /**
+     * @returns An array of all the developer guild IDs which was set when instantiating CommandKit.
+     */
+    get devGuildIds(): string[];
+    /**
+     * @returns An array of all the developer role IDs which was set when instantiating CommandKit.
+     */
+    get devRoleIds(): string[];
+    /**
+     * Increment the client listeners count.
+     */
+    incrementClientListenersCount(): void;
+    /**
+     * Decrement the client listeners count.
+     */
+    decrementClientListenersCount(): void;
+}
+
+interface CommandKitConfig {
+    /**
+     * The source directory of the project.
+     */
+    src: string;
+    /**
+     * The main "javascript" file of the project.
+     */
+    main: string;
+    /**
+     * Whether or not to use the watch mode. Defaults to `true`.
+     */
+    watch: boolean;
+    /**
+     * The output directory of the project. Defaults to `dist`.
+     */
+    outDir: string;
+    /**
+     * Whether or not to include extra env utilities. Defaults to `true`.
+     */
+    envExtra: boolean;
+    /**
+     * Node.js cli options.
+     */
+    nodeOptions: string[];
+    /**
+     * Whether or not to clear default restart logs. Defaults to `true`.
+     */
+    clearRestartLogs: boolean;
+    /**
+     * Whether or not to minify the output. Defaults to `false`.
+     */
+    minify: boolean;
+    /**
+     * Whether or not to include sourcemaps in production build. Defaults to `false`.
+     */
+    sourcemap: boolean | 'inline';
+    /**
+     * Whether or not to include anti-crash handler in production. Defaults to `true`.
+     */
+    antiCrash: boolean;
+    /**
+     * Whether or not to polyfill `require` function. Defaults to `true`.
+     */
+    requirePolyfill: boolean;
+}
+declare function getConfig(): CommandKitConfig;
+declare const requiredProps: readonly ["src", "main"];
+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>;
+    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>;
+}
+
+type AsyncFunction<R extends any[] = any[], T = any> = (...args: R) => Promise<T>;
+interface CacheTag {
+    tag: string;
+    ttl: number | string;
+}
+interface CacheParams extends CacheTag {
+    target: GenericFunction;
+    memo: GenericFunction;
+}
+/**
+ * Cache a function with a specific tag and time-to-live.
+ * @param fn The function to cache.
+ * @param params The cache tag and time-to-live.
+ * @returns The memoized function.
+ */
+declare function cache<R extends any[], F extends AsyncFunction<R>>(fn: F, params?: Partial<CacheTag>): F;
+/**
+ * **DO NOT USE THIS FUNCTION DIRECTLY**
+ * @internal
+ * @private
+ */
+declare function useCache<R extends any[], F extends AsyncFunction<R>>(fn: F, id?: string, tag?: CacheTag): F;
+/**
+ * Tags the current function with the given cache tag name
+ * @param tag The cache tag name.
+ */
+declare function cacheTag(tag: string): void;
+/**
+ * Tags the current function with the given cache tag parameters.
+ * @param tag The cache tag parameters.
+ */
+declare function cacheTag(tag: CacheTag): void;
+/**
+ * Sets the time-to-live for the current cache tag.
+ * @param life The time-to-live value in milliseconds or a string.
+ */
+declare function cacheLife(life: string): void;
+declare function cacheLife(life: number): void;
+/**
+ * Invalidates the cache with the given tag.
+ * This will immediately remove the cache entry. The next time cache is requested, it will be re-fetched.
+ * @param tag The cache tag to invalidate.
+ */
+declare function invalidate(tag: string): Promise<void>;
+/**
+ * Revalidates the cache with the given tag.
+ * This will immediately remove the cache entry and re-fetch the value.
+ * @param tag The cache tag to revalidate.
+ * @param args The arguments to pass to the memoized function (if any).
+ * @returns The new value of the cache.
+ */
+declare function revalidate<R = any>(tag: string, ...args: any[]): Promise<R | undefined>;
+
+/**
+ * Creates a command line interface for CommandKit.
+ * @param argv The arguments passed to the CLI.
+ * @param options The options passed to the CLI.
+ */
+declare function bootstrapCommandkitCLI(argv: string[], options?: commander.ParseOptions | undefined): Promise<void>;
 
 /**
  * The current version of CommandKit.
  */
 declare const version: string;
 
-export { CommandKit, CommandKit as default, version };
+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 };