bakit 2.0.0-alpha.3 → 2.0.0-alpha.30

package/dist/index.d.ts

@@ -1,34 +1,44 @@
 import * as discord_js from 'discord.js';
-import { GatewayIntentBits, ClientOptions, ChatInputCommandInteraction, CacheType, Message, User, MessageCreateOptions, InteractionReplyOptions, Awaitable, Collection, ClientEvents, Events, IntentsBitField, Client } from 'discord.js';
-import z$1, { z } from 'zod';
+import { ChatInputCommandInteraction, CacheType, Message, User, MessageCreateOptions, InteractionReplyOptions, Awaitable, Collection, Events, IntentsBitField, ClientEvents, Client, ClientOptions, GatewayIntentBits } from 'discord.js';
 import { inspect } from 'node:util';
+import z from 'zod';
+import EventEmitter from 'node:events';
+import { Serializable, ChildProcess } from 'node:child_process';
+import { MessagePort as MessagePort$1 } from 'node:worker_threads';
 
-declare const ProjectConfigSchema: z.ZodObject<{
-    intents: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodBigInt, z.ZodArray<z.ZodEnum<typeof GatewayIntentBits>>]>>;
-    clientOptions: z.ZodOptional<z.ZodCustom<Omit<ClientOptions, "intents">, Omit<ClientOptions, "intents">>>;
-    entryDir: z.ZodDefault<z.ZodString>;
-    prefixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    token: z.ZodString;
-}, z.core.$strip>;
-type ProjectConfigInput = z.input<typeof ProjectConfigSchema>;
-type ProjectConfig = z.output<typeof ProjectConfigSchema>;
-/**
- * Define config object for your project. This is just a cleaner way to define config.
- * @param config The partial version of project config.
- * @returns The same config you provided earlier.
- */
-declare function defineConfig(config: ProjectConfigInput): ProjectConfigInput;
-/**
- * Load the config file and save them for later usage.
- * @param cwd The location of the config file, uses root by default.
- * @returns The complete config with default values from the validation.
- */
-declare function loadConfig(cwd?: string): Promise<ProjectConfig>;
-/**
- * Get the loaded config of the project.
- * @returns The project config.
- */
-declare function getConfig(): ProjectConfig;
+declare enum ParamUserType {
+    Bot = "bot",
+    Normal = "normal",
+    Any = "any"
+}
+declare const BaseParamSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.z.core.$strip>;
+declare const StringParamSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+}, z.z.core.$strip>;
+declare const NumberParamSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    maxValue: z.ZodOptional<z.ZodNumber>;
+    minValue: z.ZodOptional<z.ZodNumber>;
+}, z.z.core.$strip>;
+declare const UserParamSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.z.core.$strip>;
+type BaseParamOptions = z.input<typeof BaseParamSchema>;
+type StringOptions = z.input<typeof StringParamSchema>;
+type NumberOptions = z.input<typeof NumberParamSchema>;
+type UserOptions = z.input<typeof UserParamSchema>;
 
 declare class Context {
     canceled: boolean;
@@ -64,64 +74,9 @@ declare class MessageContext<Cached extends boolean = boolean, InGuild extends b
 }
 type CommandContext<Cached extends boolean = boolean, InGuild extends boolean = boolean> = ChatInputContext<Cached, InGuild> | MessageContext<Cached, InGuild>;
 
-declare enum HookState {
-    Pre = "PRE",
-    Main = "MAIN",
-    Post = "POST",
-    Error = "ERROR"
-}
-declare enum HookOrder {
-    First = 0,
-    Last = 1
-}
-type MainHookCallback<C extends Context, Args extends unknown[]> = (context: C, ...args: Args) => Awaitable<void>;
-type ErrorHookCallback<C extends Context, Args extends unknown[]> = (context: C, error: unknown, ...args: Args) => Awaitable<void>;
-declare class LifecycleManager<C extends Context, Args extends unknown[]> {
-    id: string;
-    private readonly hooks;
-    constructor(id: string);
-    getName(name: string): string;
-    setHook(name: string, state: HookState.Post, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
-    setHook(name: string, state: HookState.Main, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
-    setHook(name: string, state: HookState.Pre, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
-    setHook(name: string, state: HookState.Error, callback: ErrorHookCallback<C, Args>, order?: HookOrder): this;
-    main(callback: MainHookCallback<C, Args>): this;
-    pre(callback: MainHookCallback<C, Args>): this;
-    post(callback: MainHookCallback<C, Args>): this;
-    error(callback: ErrorHookCallback<C, Args>): this;
-    execute(context: C, ...args: Args): Promise<void>;
-}
-
-declare enum ParamUserType {
-    Bot = "bot",
-    Normal = "normal",
-    Any = "any"
-}
-declare const BaseParamSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    required: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
-declare const StringParamSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    required: z.ZodDefault<z.ZodBoolean>;
-    maxLength: z.ZodOptional<z.ZodNumber>;
-    minLength: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-declare const NumberParamSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    required: z.ZodDefault<z.ZodBoolean>;
-    maxValue: z.ZodOptional<z.ZodNumber>;
-    minValue: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-type BaseParamOptions = z.input<typeof BaseParamSchema>;
-type StringOptions = z.input<typeof StringParamSchema>;
-type NumberOptions = z.input<typeof NumberParamSchema>;
-
 type ParamResolvedOutputType<OutputType, Required extends boolean = true> = Required extends true ? OutputType : OutputType | null;
 declare abstract class BaseParam<Options extends BaseParamOptions, OutputType, Required extends boolean = true> {
+    private schema;
     options: Options & {
         required: Required;
     };
@@ -134,13 +89,13 @@ declare abstract class BaseParam<Options extends BaseParamOptions, OutputType, R
      * @internal
      */
     readonly _type: Required extends true ? OutputType : OutputType | null;
-    constructor(options: Options);
+    constructor(options: Options, schema: z.ZodObject);
     protected setOption(key: keyof Options, value: any): this;
     name(value: string): this;
     description(value: string): this;
     required<V extends boolean>(value: V): BaseParam<Options, OutputType, V>;
     resolve(context: CommandContext, value?: string): Promise<ParamResolvedOutputType<OutputType, Required>>;
-    abstract resolveMessage(context: MessageContext, value: string | undefined): Awaitable<ParamResolvedOutputType<OutputType, Required>>;
+    abstract resolveMessage(context: MessageContext, value: string): Awaitable<ParamResolvedOutputType<OutputType, Required>>;
     abstract resolveChatInput(context: ChatInputContext): Awaitable<ParamResolvedOutputType<OutputType, Required>>;
     /**
      * Helper to normalize string inputs into an options object.
@@ -150,7 +105,7 @@ declare abstract class BaseParam<Options extends BaseParamOptions, OutputType, R
 declare class StringParam<Required extends boolean = true> extends BaseParam<StringOptions, string, Required> {
     constructor(options: string | StringOptions);
     required<V extends boolean>(value: V): StringParam<V>;
-    resolveMessage(_context: CommandContext, value: string | undefined): ParamResolvedOutputType<string, Required>;
+    resolveMessage(_context: CommandContext, value: string): ParamResolvedOutputType<string, Required>;
     resolveChatInput(context: ChatInputContext): ParamResolvedOutputType<string, Required>;
     /**
      * Sets the minimum allowed length for this string.
@@ -166,7 +121,7 @@ declare class StringParam<Required extends boolean = true> extends BaseParam<Str
 declare class NumberParam<Required extends boolean = true> extends BaseParam<NumberOptions, number, Required> {
     constructor(options: string | NumberOptions);
     required<V extends boolean>(value: V): NumberParam<V>;
-    resolveMessage(ctx: CommandContext, value: string | undefined): ParamResolvedOutputType<number, Required>;
+    resolveMessage(_context: CommandContext, value: string): ParamResolvedOutputType<number, Required>;
     resolveChatInput(context: ChatInputContext): ParamResolvedOutputType<number, Required>;
     /**
      * Sets the minimum allowed value for this number.
@@ -179,6 +134,12 @@ declare class NumberParam<Required extends boolean = true> extends BaseParam<Num
      */
     max(value: number | null): this;
 }
+declare class UserParam<Required extends boolean = true> extends BaseParam<UserOptions, User, Required> {
+    constructor(options: string | UserOptions);
+    required<V extends boolean>(value: V): UserParam<V>;
+    resolveMessage(context: CommandContext, value: string): Promise<ParamResolvedOutputType<User, Required>>;
+    resolveChatInput(context: ChatInputContext): ParamResolvedOutputType<User, Required>;
+}
 type AnyParam<Required extends boolean = true> = BaseParam<any, any, Required>;
 /**
  * Helper type to extract the runtime value of a Param instance.
@@ -192,10 +153,40 @@ type InferParamTuple<T extends readonly BaseParam<any, any, any>[]> = {
     [K in keyof T]: T[K] extends AnyParam<any> ? InferParamValue<T[K]> : never;
 };
 
+declare enum HookState {
+    Pre = "PRE",
+    Main = "MAIN",
+    Post = "POST",
+    Error = "ERROR"
+}
+declare enum HookOrder {
+    First = 0,
+    Last = 1
+}
+type MainHookCallback<C extends Context, Args extends unknown[]> = (context: C, ...args: Args) => Awaitable<void>;
+type ErrorHookCallback<C extends Context, Args extends unknown[]> = (context: C, error: unknown, ...args: Args) => Awaitable<void>;
+declare class LifecycleManager<C extends Context, Args extends unknown[]> {
+    id: string;
+    private readonly hooks;
+    constructor(id: string);
+    getName(name: string): string;
+    setHook(name: string, state: HookState.Post, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
+    setHook(name: string, state: HookState.Main, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
+    setHook(name: string, state: HookState.Pre, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
+    setHook(name: string, state: HookState.Error, callback: ErrorHookCallback<C, Args>, order?: HookOrder): this;
+    main(callback: MainHookCallback<C, Args>): this;
+    pre(callback: MainHookCallback<C, Args>): this;
+    post(callback: MainHookCallback<C, Args>): this;
+    error(callback: ErrorHookCallback<C, Args>): this;
+    execute(context: C, ...args: Args): Promise<void>;
+}
+
+declare function validateParamsOrder(params: readonly AnyParam<boolean>[]): boolean;
 declare const CommandOptionsSchema: z.ZodPipe<z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    params: z.ZodDefault<z.ZodArray<z.ZodCustom<BaseParam<{
+    name: z.ZodReadonly<z.ZodString>;
+    description: z.ZodReadonly<z.ZodOptional<z.ZodString>>;
+    nsfw: z.ZodReadonly<z.ZodDefault<z.ZodBoolean>>;
+    params: z.ZodReadonly<z.ZodDefault<z.ZodArray<z.ZodCustom<BaseParam<{
         name: string;
         description?: string | undefined;
         required?: boolean | undefined;
@@ -203,12 +194,13 @@ declare const CommandOptionsSchema: z.ZodPipe<z.ZodObject<{
         name: string;
         description?: string | undefined;
         required?: boolean | undefined;
-    }, unknown, boolean>>>>;
-    quotes: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>, z.ZodTransform<{
+    }, unknown, boolean>>>>>;
+    quotes: z.ZodReadonly<z.ZodDefault<z.ZodBoolean>>;
+}, z.z.core.$strip>, z.ZodTransform<{
     description: string;
     name: string;
-    params: BaseParam<{
+    nsfw: boolean;
+    params: readonly BaseParam<{
         name: string;
         description?: string | undefined;
         required?: boolean | undefined;
@@ -216,7 +208,8 @@ declare const CommandOptionsSchema: z.ZodPipe<z.ZodObject<{
     quotes: boolean;
 }, {
     name: string;
-    params: BaseParam<{
+    nsfw: boolean;
+    params: readonly BaseParam<{
         name: string;
         description?: string | undefined;
         required?: boolean | undefined;
@@ -237,6 +230,9 @@ declare class Command<ParamsList extends readonly AnyParam<any>[] = any[]> exten
         params?: ParamsList;
     }) | string);
     private handleSyntaxError;
+    toSlashCommandJSON(): discord_js.RESTPostAPIChatInputApplicationCommandsJSONBody;
+    private initSlashCommandOptions;
+    private initSlashCommandOption;
 }
 /**
  * Define command entry, usually for modules.
@@ -262,54 +258,147 @@ declare function defineCommand<const ParamsList extends readonly AnyParam<any>[]
     params?: ParamsList;
 }) | string): Command<ParamsList>;
 
-declare class BaseClientManager {
-    client: BakitClient;
-    constructor(client: BakitClient);
+declare abstract class HotReloadable {
+    entryDirectory: string;
+    constructor(entryDirectory: string);
+    abstract unload(path: string): Promise<unknown>;
+    abstract load(path: string): Promise<unknown>;
+    abstract reload(path: string): Promise<unknown>;
+    protected unloadFile(path: string): Promise<boolean>;
 }
 
-declare class CommandManager extends BaseClientManager {
+declare class CommandManager extends HotReloadable {
+    client: BakitClient;
     commands: Collection<string, Command<any[]>>;
+    entries: Collection<string, Command<any[]>>;
+    constructor(client: BakitClient);
     loadModules(): Promise<Command[]>;
+    /**
+     * Load the file and add the command to the registry.
+     * @param path The path to the command file.
+     * @returns The command object if added successfully.
+     */
+    load(path: string): Promise<Command | undefined>;
+    /**
+     * Unload the file and remove the command from the registry.
+     * @param path The path to the command file.
+     * @returns The command object if unloaded successfully.
+     */
+    unload(path: string): Promise<Command | undefined>;
+    reload(path: string): Promise<Command<any[]> | undefined>;
+    /**
+     * Add a command to the registry.
+     * @param command Command to add.
+     */
     add(command: Command): void;
+    /**
+     * Remove a command from the registry.
+     * @param target Command name or object to remove.
+     * @returns The command object if removed successfully.
+     */
     remove(target: string | Command): Command | undefined;
+    /**
+     * Get a command using its name.
+     * @param name The command to get.
+     * @returns The command object.
+     */
     get(name: string): Command<any[]> | undefined;
 }
 
-declare const ListenerOptionsSchema: z$1.ZodObject<{
-    name: z$1.ZodEnum<typeof Events>;
-    once: z$1.ZodDefault<z$1.ZodBoolean>;
-}, z$1.z.core.$strip>;
-type ListenerOptions<K extends EventKey = EventKey> = Omit<z$1.input<typeof ListenerOptionsSchema>, "name"> & {
+declare const ListenerOptionsSchema: z.ZodObject<{
+    name: z.ZodEnum<typeof Events>;
+    once: z.ZodDefault<z.ZodBoolean>;
+}, z.z.core.$strip>;
+type ListenerOptions<K extends EventKey = EventKey> = Omit<z.input<typeof ListenerOptionsSchema>, "name"> & {
     name: K;
 };
-type EventKey = keyof ClientEvents;
-declare class Listener<K extends EventKey = EventKey> extends LifecycleManager<Context, [...args: ClientEvents[K]]> {
+type EventKey = keyof BakitClientEvents;
+declare class Listener<K extends EventKey = EventKey> extends LifecycleManager<Context, [
+    ...args: BakitClientEvents[K]
+]> {
     options: ListenerOptions<K>;
     constructor(options: K | ListenerOptions<K>);
 }
 declare function defineListener<const K extends EventKey = EventKey>(options: K | ListenerOptions<K>): Listener<K>;
 
-declare class ListenerManager extends BaseClientManager {
+declare class ListenerManager extends HotReloadable {
+    client: BakitClient;
     listeners: Listener[];
+    entries: Collection<string, Listener<keyof BakitClientEvents>>;
     private executors;
+    constructor(client: BakitClient);
     loadModules(): Promise<Listener[]>;
+    /**
+     * Load the file and add the listener to the registry.
+     * @param path The path to the listener file.
+     * @returns The listener object if added successfully.
+     */
+    load(path: string): Promise<Listener | undefined>;
+    /**
+     * Unload the file and remove the listener from the registry.
+     * @param path The path to the listener file.
+     * @returns The listener object if unloaded successfully.
+     */
+    unload(path: string): Promise<Listener | undefined>;
+    reload(path: string): Promise<Listener<keyof BakitClientEvents> | undefined>;
+    /**
+     * Add a listener to the registry and create a listener for client.
+     * @param listener Listener to add.
+     */
     add(listener: Listener): void;
+    /**
+     * Remove a listener from the registry and client.
+     * @param target Listener name or object to remove.
+     * @returns The list of listener objects if removed successfully.
+     */
     remove(target: string | Listener): Listener[];
+    /**
+     * Get a list of required intents for Bakit to run correctly.
+     * @returns Used intents.
+     */
     getBaseIntents(): IntentsBitField;
+    /**
+     * Get a list of needed intents based on registered listeners to receive needed events.
+     * @returns Used intents.
+     */
     getNeededIntents(): IntentsBitField;
 }
 
+declare class ProjectCacheManager {
+    private readonly rootDir;
+    constructor(root?: string);
+    private ensureRoot;
+    getHash(data: unknown): string;
+    write(path: string, data: unknown): Promise<void>;
+    read<T>(path: string): Promise<T | null>;
+    clear(): Promise<void>;
+    clearSync(): void;
+}
+
+declare class Instance {
+    client: BakitClient;
+    cache: ProjectCacheManager;
+    constructor();
+    start(): Promise<void>;
+    private initProcess;
+    private loadModules;
+    private initIntents;
+    shutdown(): Promise<void>;
+}
+declare function useApp(): Instance;
+
 type GetPrefixFunction = (message: Message) => Awaitable<string[] | string>;
 interface BakitClientEvents extends ClientEvents {
     ready: [BakitClient<true>];
     clientReady: [BakitClient<true>];
 }
 declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready> {
+    instance: Instance;
     managers: {
         commands: CommandManager;
         listeners: ListenerManager;
     };
-    constructor(options: ClientOptions);
+    constructor(options: ClientOptions, instance: Instance);
     /**
      * Check if the client is connected to gateway successfully and finished initialization.
      */
@@ -327,6 +416,11 @@ declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready>
     [inspect.custom](): string;
 }
 
+declare class BaseClientManager {
+    client: BakitClient;
+    constructor(client: BakitClient);
+}
+
 declare const Params: {
     readonly string: <Required extends boolean = true>(options: string | {
         name: string;
@@ -342,6 +436,239 @@ declare const Params: {
         maxValue?: number | undefined;
         minValue?: number | undefined;
     }) => NumberParam<Required>;
+    readonly user: <Required extends boolean = true>(options: string | {
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+    }) => UserParam<Required>;
 };
 
-export { type AnyParam, BakitClient, type BakitClientEvents, BaseCommandContext, BaseParam, type BaseParamOptions, BaseParamSchema, ChatInputContext, type ChatInputContextSendOptions, Command, type CommandContext, CommandManager, type CommandOptions, type CommandOptionsInput, CommandOptionsSchema, type ContextSendOptions, type GetPrefixFunction, type InferParamTuple, type InferParamValue, Listener, ListenerManager, type ListenerOptions, ListenerOptionsSchema, MessageContext, type MessageContextSendOptions, type NumberOptions, NumberParam, NumberParamSchema, type ParamResolvedOutputType, ParamUserType, Params, type ProjectConfig, type ProjectConfigInput, ProjectConfigSchema, type StringOptions, StringParam, StringParamSchema, defineCommand, defineConfig, defineListener, getConfig, loadConfig };
+declare const EVENT_INTENT_MAPPING: Record<string, number[]>;
+
+declare class BakitError extends Error {
+    constructor(message: string);
+}
+
+declare class ArgumentError extends BakitError {
+    target: string;
+    reason: string;
+    constructor(target: string, reason: string);
+}
+
+declare function tokenize(content: string): string[];
+/**
+ * Extracts a valid Discord Snowflake (User ID, Channel ID, etc.) from a string.
+ * @param input The raw string to parse
+ * @returns The extracted ID string, or null if invalid
+ */
+declare function extractSnowflakeId(input: string): string | null;
+
+declare function getTopLevelDirectory(path: string, entryDir: string): string | null;
+declare function getEntryDirectory(): string;
+declare function getEntryFile(): string;
+
+declare const hotReloaders: Collection<string, HotReloadable>;
+/**
+ * Initliazie the loader
+ */
+declare function init(): void;
+/**
+ * Register a reloader for HMR.
+ * @param reloader Reloader extended from HotReloadable.
+ */
+declare function addHotReloader(reloader: HotReloadable): void;
+/**
+ * Remove the previous version of the file.
+ * @param path Path to unload.
+ * @returns `true` for unloaded successfully, `false` for unload failed.
+ */
+declare function unload(path: string): Promise<boolean>;
+/**
+ * Get a list of the files which imported the target.
+ * @param path Target file path to get.
+ * @param createNew Create a new Set cache for the target path.
+ */
+declare function getImporters(path: string, createNew?: false): Set<string> | undefined;
+declare function getImporters(path: string, createNew: true): Set<string>;
+/**
+ * Get a list of the files which imported the target.
+ * @param path Target file path to get.
+ * @param createNew Create a new Set cache for the target path.
+ */
+declare function getImports(path: string): string[];
+/**
+ * Get a chain of dependencies for affected files.
+ * @param path
+ * @returns An array of affected dependencies.
+ */
+declare function getDependencyChain(path: string): string[];
+/**
+ * Checks if the target file imports any of the files in the 'targets' set.
+ * @param path The file path to check.
+ * @param targets The list of the files to check.
+ */
+declare function importsAny(path: string, targets: Set<string>): boolean;
+/**
+ * Check if the file is imported by the others.
+ * @param path The path of the file to check.
+ * @returns `boolean`
+ */
+declare function isImported(path: string): boolean;
+/**
+ * Check if the file is imported by a specific target.
+ * @param path The path of the file to check.
+ * @param matcher The target condition to match.
+ * @returns `boolean`
+ */
+declare function isImportedBy(path: string, matcher: string | RegExp | ((path: string) => boolean)): boolean;
+/**
+ * Check if the file is under a hmr directory.
+ * @param path The path of the file to check.
+ * @returns `boolean`
+ */
+declare function isInHotDirectory(path: string): boolean | undefined;
+/**
+ * Check if the file is the entry file (e.g, index.ts)
+ * @param path The path of the file to check.
+ * @returns `boolean`
+ */
+declare function isEntryFile(path: string): boolean;
+/**
+ * Check if the file chain includes the entry file (e.g, index.ts)
+ * @param path The chain of the files to check.
+ * @returns `boolean`
+ */
+declare function containsEntryFile(chain: string[]): boolean;
+/**
+ * Check if the file chain includes hmr files (e.g, index.ts)
+ * @param path The chain of the files to check.
+ * @returns `boolean`
+ */
+declare function containsHotModule(chain: string[]): boolean;
+/**
+ * Request to dev process manager to restart the process.
+ */
+declare function restartProcess(): void;
+
+declare const loader_addHotReloader: typeof addHotReloader;
+declare const loader_containsEntryFile: typeof containsEntryFile;
+declare const loader_containsHotModule: typeof containsHotModule;
+declare const loader_getDependencyChain: typeof getDependencyChain;
+declare const loader_getImporters: typeof getImporters;
+declare const loader_getImports: typeof getImports;
+declare const loader_hotReloaders: typeof hotReloaders;
+declare const loader_importsAny: typeof importsAny;
+declare const loader_init: typeof init;
+declare const loader_isEntryFile: typeof isEntryFile;
+declare const loader_isImported: typeof isImported;
+declare const loader_isImportedBy: typeof isImportedBy;
+declare const loader_isInHotDirectory: typeof isInHotDirectory;
+declare const loader_restartProcess: typeof restartProcess;
+declare const loader_unload: typeof unload;
+declare namespace loader {
+  export { loader_addHotReloader as addHotReloader, loader_containsEntryFile as containsEntryFile, loader_containsHotModule as containsHotModule, loader_getDependencyChain as getDependencyChain, loader_getImporters as getImporters, loader_getImports as getImports, loader_hotReloaders as hotReloaders, loader_importsAny as importsAny, loader_init as init, loader_isEntryFile as isEntryFile, loader_isImported as isImported, loader_isImportedBy as isImportedBy, loader_isInHotDirectory as isInHotDirectory, loader_restartProcess as restartProcess, loader_unload as unload };
+}
+
+declare const RPC_RESPONSE_MARK = "$DONE:";
+declare const RPC_RESPONSE_TIMEOUT = 5000;
+interface BaseRPCMessage {
+    id: string;
+}
+interface BaseRPCResponse {
+    id: `${typeof RPC_RESPONSE_MARK}${string}`;
+}
+interface RPCRequest<Data extends Serializable = Serializable> extends BaseRPCMessage {
+    type: string;
+    data: Data;
+}
+interface RPCSuccessResponse<Data extends Serializable = Serializable> extends BaseRPCResponse {
+    data: Data;
+}
+interface RPCErrorResponse extends BaseRPCResponse {
+    error: string;
+}
+type RPCResponse<Data extends Serializable = Serializable> = RPCSuccessResponse<Data> | RPCErrorResponse;
+type RPCMessage<Data extends Serializable = Serializable> = RPCRequest<Data> | RPCResponse<Data>;
+interface RPCPendingPromise {
+    resolve: (data: any) => void;
+    reject: (error: unknown) => void;
+    timeout: NodeJS.Timeout;
+}
+declare class RPC extends EventEmitter {
+    transport: MessagePort$1 | NodeJS.Process | ChildProcess;
+    requests: Map<string, RPCPendingPromise>;
+    constructor(transport: MessagePort$1 | NodeJS.Process | ChildProcess);
+    postMessage(message: Serializable): void;
+    private onMessage;
+    private handleResponseMessage;
+    private handleRequestMessage;
+    send<Data extends Serializable>(type: string, data?: Data, id?: string): void;
+    success<Data extends Serializable>(id: string, data: Data): void;
+    error(id: string, error: string): void;
+    request<Data extends Serializable, Output extends Serializable>(type: string, data: Data, id?: string): Promise<Output>;
+}
+
+declare const messageCommandHandler: Listener<Events.MessageCreate>;
+declare const chatInputCommandHandler: Listener<Events.InteractionCreate>;
+declare const registerCommandsHandler: Listener<Events.ClientReady>;
+
+declare const ProjectConfigSchema: z.ZodObject<{
+    intents: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodBigInt, z.ZodArray<z.ZodEnum<typeof GatewayIntentBits>>]>>;
+    clientOptions: z.ZodOptional<z.ZodCustom<Omit<ClientOptions, "intents">, Omit<ClientOptions, "intents">>>;
+    prefixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    token: z.ZodString;
+    entryDirectory: z.ZodDefault<z.ZodString>;
+}, z.z.core.$strip>;
+type ProjectConfigInput = z.input<typeof ProjectConfigSchema>;
+type ProjectConfig = z.output<typeof ProjectConfigSchema>;
+/**
+ * Define config object for your project. This is just a cleaner way to define config.
+ * @param config The partial version of project config.
+ * @returns The same config you provided earlier.
+ */
+declare function defineConfig(config: ProjectConfigInput): ProjectConfigInput;
+/**
+ * Load the config file and save them for later usage.
+ * @param cwd The location of the config file, uses root by default.
+ * @returns The complete config with default values from the validation.
+ */
+declare function loadConfig(cwd?: string): Promise<ProjectConfig>;
+/**
+ * Get the loaded config of the project.
+ * @returns The project config.
+ */
+declare function getConfig(): ProjectConfig;
+
+interface InitializeData {
+	port: MessagePort;
+}
+
+interface ResolveContext {
+	conditions: string[];
+	importAttributes: Record<string, string>;
+	parentURL?: string;
+}
+
+interface ResolveResult {
+	url: string;
+	shortCircuit?: boolean;
+	format?: string | null | undefined;
+	importAttributes?: Record<string, string>;
+}
+
+interface LoadContext {
+	conditions: string[];
+	format: string | null | undefined;
+	importAttributes: Record<string, string>;
+}
+
+interface LoadResult {
+	source: string | ArrayBuffer | Uint8Array;
+	format: string;
+	shortCircuit?: boolean;
+}
+
+type NextResolve = (specifier: string, context: ResolveContext) => Promise<ResolveResult>;
+type NextLoad = (url: string, context: LoadContext) => Promise<LoadResult>;
+
+export { type AnyParam, ArgumentError, BakitClient, type BakitClientEvents, BakitError, BaseClientManager, BaseCommandContext, BaseParam, type BaseParamOptions, BaseParamSchema, type BaseRPCMessage, type BaseRPCResponse, ChatInputContext, type ChatInputContextSendOptions, Command, type CommandContext, CommandManager, type CommandOptions, type CommandOptionsInput, CommandOptionsSchema, Context, type ContextSendOptions, EVENT_INTENT_MAPPING, type ErrorHookCallback, type GetPrefixFunction, HookOrder, HookState, HotReloadable, type InferParamTuple, type InferParamValue, type InitializeData, Instance, LifecycleManager, Listener, ListenerManager, type ListenerOptions, ListenerOptionsSchema, type LoadContext, type LoadResult, loader as Loader, type MainHookCallback, MessageContext, type MessageContextSendOptions, type NextLoad, type NextResolve, type NumberOptions, NumberParam, NumberParamSchema, type ParamResolvedOutputType, ParamUserType, Params, ProjectCacheManager, type ProjectConfig, type ProjectConfigInput, ProjectConfigSchema, RPC, type RPCErrorResponse, type RPCMessage, type RPCPendingPromise, type RPCRequest, type RPCResponse, type RPCSuccessResponse, RPC_RESPONSE_MARK, RPC_RESPONSE_TIMEOUT, type ResolveContext, type ResolveResult, type StringOptions, StringParam, StringParamSchema, type UserOptions, UserParam, UserParamSchema, chatInputCommandHandler, defineCommand, defineConfig, defineListener, extractSnowflakeId, getConfig, getEntryDirectory, getEntryFile, getTopLevelDirectory, loadConfig, messageCommandHandler, registerCommandsHandler, tokenize, useApp, validateParamsOrder };