bakit 1.0.0-beta.9 → 2.0.0-alpha.10

package/README.md

@@ -0,0 +1,35 @@
+# About us
+
+Bakit is a framework that makes building Discord bots easier.
+It's built on top of [discord.js](https://discord.js.org) and helps you handle the core system for your bot.
+
+<div align="center">
+	<a href="https://npmjs.com/package/bakit"><img src="https://img.shields.io/npm/v/bakit?logo=npm" alt="npm" /></a>
+	<a href="LICENSE"><img src="https://img.shields.io/github/license/louiszn/bakit" alt="License" /></a>
+	<a href="https://discord.gg/pGnKbMfXke"><img src="https://img.shields.io/discord/1353321517437681724?logo=discord&logoColor=white" alt="Discord" /></a>
+</div>
+
+> [!CAUTION]
+> This package is currently being rewritten. Many features from beta v1 have not yet been migrated.
+> It is not production-ready, and use in production environments is strongly discouraged.
+
+## Why Bakit?
+
+- 🧩 **Unified Command System** - write once for both slash and prefix command.
+- 🚀 **Clean API interfaces** - well-structured commands and events.
+- ⚡ **Lightweight** - minimal overhead, only what you need.
+- ✨ **TypeScript + ESM first** - modern JavaScript tooling out of the box.
+
+## Documentation
+
+Official documentation is now at https://bakit.louiszn.xyz.
+
+# Contributing
+
+Contributions are always welcome! But before doing that, make sure you have already checked existing issues and pull requests before making a new one.
+
+# Support
+
+If you like Bakit and want to support its development, you can buy me a coffee:
+
+[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/louiszn)

package/bin/bakit.js

@@ -0,0 +1,39 @@
+// @ts-check
+import { config as useEnv } from "dotenv";
+import { program } from "commander";
+
+program.name("bakit");
+
+program.command("dev").action(async () => {
+	useEnv({
+		path: [".env.local", ".env"],
+		quiet: true,
+	});
+	const { default: nodemon } = await import("nodemon");
+
+	nodemon({
+		script: "src/index.ts",
+		exec: `${process.execPath} --import tsx`,
+		ext: "ts,js",
+		watch: ["src"],
+		env: {
+			...process.env,
+			FORCE_COLOR: "1",
+			NODE_ENV: "development",
+		},
+	});
+
+	nodemon.on("start", () => {
+		console.log("Starting bakit app...");
+	});
+
+	nodemon.on("restart", () => {
+		console.log("Bakit detected changes! Restarting...");
+	});
+
+	nodemon.on("quit", () => {
+		process.exit();
+	});
+});
+
+program.parse();

package/dist/index.d.ts

@@ -1,96 +1,414 @@
-import { B as BaseEntry, C as ConstructorLike, a as BaseHook, b as BaseMainHookMethod, c as BaseErrorHookMethod, d as BakitClient } from './BakitClient-D9kRvFS3.js';
-export { A as Arg, h as ArgumentOptions, f as ArgumentType, e as BakitClientOptions, g as BaseArgumentOptions, m as BaseCommandEntry, k as BaseCommandEntryOptions, n as BaseCommandGroupEntry, x as BaseContext, y as ChatInputContext, u as ChatInputContextSendOptions, s as Command, q as CommandAPI, r as CommandFactory, o as CommandGroupEntry, j as CommandHook, t as CommandRegistry, J as CommandSyntaxError, H as CommandSyntaxErrorOptions, F as CommandSyntaxErrorType, D as Context, w as ContextSendOptions, l as CreateCommandOptions, E as ErrorCommandHookMethod, G as GetSyntaxErrorMessageFunction, I as IntegerArgumentOptions, i as MainCommandHookMethod, M as MemberArgumentOptions, z as MessageContext, v as MessageContextSendOptions, N as NumberArgumentOptions, R as RootCommandEntry, S as StringArgumentOptions, p as SubcommandEntry, U as UserArgumentOptions } from './BakitClient-D9kRvFS3.js';
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { ClientEvents } from 'discord.js';
-import EventEmitter from 'node:events';
-import { SetOptional } from 'type-fest';
-
-declare function extractId(value: string): string | null;
-
-type States = Record<string | symbol, unknown>;
-declare class StateBox {
-    private static readonly STATES_KEY;
-    static storage: AsyncLocalStorage<States>;
-    private static getState;
-    static run<R>(fn: () => R, store?: {}): R;
-    static wrap<R>(fn: () => R): () => R;
-    static use<T extends object>(defaultValue?: unknown): (target: T, key: keyof T) => void;
-}
-
-type EventsLike = Record<keyof unknown, unknown[]>;
-type MainListenerHookMethod<Args extends unknown[]> = BaseMainHookMethod<Args>;
-type ErrorListenerHookMethod<Args extends unknown[]> = BaseErrorHookMethod<Args>;
-interface ListenerHook<E extends EventsLike, K extends keyof E> extends BaseHook {
-    method: MainListenerHookMethod<E[K] & unknown[]> | ErrorListenerHookMethod<E[K] & unknown[]>;
-}
-interface ListenerEntryOptions<E extends EventsLike, K extends keyof E> {
-    name: K;
-    once: boolean;
-    emitter?: EventEmitter;
+import * as discord_js from 'discord.js';
+import { GatewayIntentBits, ClientOptions, ChatInputCommandInteraction, CacheType, Message, User, MessageCreateOptions, InteractionReplyOptions, Awaitable, Collection, Events, IntentsBitField, Client, ClientEvents } from 'discord.js';
+import z$1, { z } from 'zod';
+import * as jiti from 'jiti';
+import { inspect } from 'node:util';
+
+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 const EVENT_INTENT_MAPPING: Record<string, number[]>;
+
+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 const $jiti: jiti.Jiti;
+
+declare class Context {
+    canceled: boolean;
+    cancel(): void;
 }
-declare class ListenerEntry<E extends EventsLike, K extends keyof E> extends BaseEntry<ConstructorLike, ListenerHook<E, K>, MainListenerHookMethod<E[K] & unknown[]>, ErrorListenerHookMethod<E[K] & unknown[]>> {
-    options: ListenerEntryOptions<E, K>;
-    constructor(options: ListenerEntryOptions<E, K>);
+
+type ChatInputContextSendOptions = string | InteractionReplyOptions;
+type MessageContextSendOptions = string | MessageCreateOptions;
+type ContextSendOptions = ChatInputContextSendOptions | MessageContextSendOptions;
+declare abstract class BaseCommandContext<Cached extends boolean, InGuild extends boolean> extends Context {
+    source: ChatInputCommandInteraction<Cached extends true ? "cached" : CacheType> | Message<InGuild>;
+    constructor(source: ChatInputCommandInteraction<Cached extends true ? "cached" : CacheType> | Message<InGuild>);
+    get client(): BakitClient<true>;
+    get channel(): discord_js.CacheTypeReducer<Cached extends true ? "cached" : CacheType, discord_js.GuildTextBasedChannel | null, discord_js.GuildTextBasedChannel | null, discord_js.GuildTextBasedChannel | null, discord_js.TextBasedChannel | null> | discord_js.If<InGuild, discord_js.GuildTextBasedChannel, discord_js.TextBasedChannel>;
+    get channelId(): string;
+    get guild(): discord_js.CacheTypeReducer<Cached extends true ? "cached" : CacheType, discord_js.Guild, null, discord_js.Guild | null, discord_js.Guild | null> | discord_js.If<InGuild, discord_js.Guild, null>;
+    get guildId(): discord_js.CacheTypeReducer<Cached extends true ? "cached" : CacheType, string, string, string, string | null> | discord_js.If<InGuild, string, null>;
+    get member(): discord_js.GuildMember | discord_js.CacheTypeReducer<Cached extends true ? "cached" : CacheType, discord_js.GuildMember, discord_js.APIInteractionGuildMember, discord_js.GuildMember | discord_js.APIInteractionGuildMember, discord_js.GuildMember | discord_js.APIInteractionGuildMember | null> | null;
+    inGuild(): this is CommandContext<Cached, true>;
+    inCachedGuild(): this is CommandContext<true, true>;
+    get user(): User;
+    isChatInput(): this is ChatInputContext;
+    isMessage(): this is MessageContext;
+    abstract send(options: ContextSendOptions): Promise<Message<InGuild>>;
+}
+declare class ChatInputContext<Cached extends boolean = boolean, InGuild extends boolean = boolean> extends BaseCommandContext<Cached, InGuild> {
+    source: ChatInputCommandInteraction<Cached extends true ? "cached" : CacheType>;
+    send(options: ContextSendOptions): Promise<Message<InGuild>>;
 }
+declare class MessageContext<Cached extends boolean = boolean, InGuild extends boolean = boolean> extends BaseCommandContext<Cached, InGuild> {
+    source: Message<InGuild>;
+    send(options: string | MessageCreateOptions): Promise<Message<InGuild>>;
+}
+type CommandContext<Cached extends boolean = boolean, InGuild extends boolean = boolean> = ChatInputContext<Cached, InGuild> | MessageContext<Cached, InGuild>;
 
-declare namespace ListenerAPI {
-    const ENTRY_KEY: unique symbol;
-    function use<E extends EventsLike, K extends keyof E>(entry: ListenerEntry<E, K>): (target: ConstructorLike) => void;
-    function getEntry<E extends EventsLike, K extends keyof E>(target: ConstructorLike): ListenerEntry<E, K> | undefined;
+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 ListenerFactory<E extends EventsLike = ClientEvents, K extends keyof E = keyof E>(options: SetOptional<ListenerEntryOptions<E, K>, "once"> | K): ListenerEntry<E, K>;
-declare const Listener: typeof ListenerFactory & typeof ListenerAPI;
 
-/**
- * The global listener registry of Bakit.
- */
-declare abstract class ListenerRegistry {
-    private static client;
-    static constructors: Set<ConstructorLike>;
-    static instances: WeakMap<ConstructorLike, object>;
-    static executors: WeakMap<object, (...args: unknown[]) => 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>;
+declare const UserParamSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, 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>;
+
+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;
+    };
     /**
-     * Add and register a listener to the registry.
-     * If `options.emitter` is not provided, the registry will use the base `client` by default.
-     * @param constructor The listener class you want to add.
+     * **Internal Phantom Type**
+     *
+     * Used strictly for TypeScript type inference to determine the runtime value
+     * of this parameter. This property does not exist at runtime.
+     *
+     * @internal
      */
-    static add(constructor: ConstructorLike): void;
+    readonly _type: Required extends true ? OutputType : OutputType | null;
+    constructor(options: Options, schema: z$1.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): Awaitable<ParamResolvedOutputType<OutputType, Required>>;
+    abstract resolveChatInput(context: ChatInputContext): Awaitable<ParamResolvedOutputType<OutputType, Required>>;
     /**
-     * Remove and unregister a listener from the registry.
-     * @param constructor The listener class you want to remove.
-     * @returns `boolean`, returns `true` if the listener is removed successfully.
+     * Helper to normalize string inputs into an options object.
      */
-    static remove(constructor: ConstructorLike): boolean;
+    protected static getOptions<Options>(options: Options | string): Options;
+}
+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): ParamResolvedOutputType<string, Required>;
+    resolveChatInput(context: ChatInputContext): ParamResolvedOutputType<string, Required>;
     /**
-     * Remove and unregister all listeners from the registry.
-     * @returns Amount of removed listeners.
+     * Sets the minimum allowed length for this string.
+     * Pass `null` to remove this constraint.
      */
-    static removeAll(): number;
+    min(length: number | null): this;
     /**
-     * Set base client for the registry to fallback as default emitter. This should be used only by BakitClient and stay untouched.
-     * @param newClient base client to set for the registry.
+     * Sets the maximum allowed length for this string.
+     * Pass `null` to remove this constraint.
      */
-    protected static setClient(newClient: BakitClient): void;
-    private static createExecutor;
+    max(length: number | null): this;
+}
+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(_context: CommandContext, value: string): ParamResolvedOutputType<number, Required>;
+    resolveChatInput(context: ChatInputContext): ParamResolvedOutputType<number, Required>;
     /**
-     * Load and add all listeners which matched provided glob pattern to the registry.
-     * @param pattern glob pattern to load.
-     * @param parallel load all matched results in parallel, enabled by default.
-     * @returns All loaded listener constructors.
+     * Sets the minimum allowed value for this number.
+     * Pass `null` to remove this constraint.
      */
-    static load(pattern: string, parallel?: boolean): Promise<ConstructorLike[]>;
+    min(value: number | null): this;
+    /**
+     * Sets the maximum allowed value for this number.
+     * Pass `null` to remove this constraint.
+     */
+    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.
+ *
+ * @example
+ * const p = new StringParam("name").required(false);
+ * type T = InferParamValue<typeof p>; // string | null
+ */
+type InferParamValue<P extends AnyParam<any>> = P["_type"];
+type InferParamTuple<T extends readonly BaseParam<any, any, any>[]> = {
+    [K in keyof T]: T[K] extends AnyParam<any> ? InferParamValue<T[K]> : never;
+};
 
+declare function validateParamsOrder(params: readonly AnyParam<boolean>[]): boolean;
+declare const CommandOptionsSchema: z.ZodPipe<z.ZodObject<{
+    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;
+    }, unknown, boolean>, BaseParam<{
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+    }, unknown, boolean>>>>>;
+    quotes: z.ZodReadonly<z.ZodDefault<z.ZodBoolean>>;
+}, z.core.$strip>, z.ZodTransform<{
+    description: string;
+    name: string;
+    nsfw: boolean;
+    params: readonly BaseParam<{
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+    }, unknown, boolean>[];
+    quotes: boolean;
+}, {
+    name: string;
+    nsfw: boolean;
+    params: readonly BaseParam<{
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+    }, unknown, boolean>[];
+    quotes: boolean;
+    description?: string | undefined;
+}>>;
+type CommandOptionsInput = z.input<typeof CommandOptionsSchema>;
+type CommandOptions = z.output<typeof CommandOptionsSchema>;
 /**
- * This file is used to redeclare original client to the custom one
- * Most of the structure is from Base, but some might be not
+ * The command entry, used for registering command.
  */
+declare class Command<ParamsList extends readonly AnyParam<any>[] = any[]> extends LifecycleManager<CommandContext, [
+    ...args: InferParamTuple<ParamsList>
+]> {
+    options: CommandOptions;
+    constructor(options: (Omit<CommandOptionsInput, "params"> & {
+        params?: ParamsList;
+    }) | string);
+    private handleSyntaxError;
+    toSlashCommandJSON(): discord_js.RESTPostAPIChatInputApplicationCommandsJSONBody;
+    private initSlashCommandOptions;
+    private initSlashCommandOption;
+}
+/**
+ * Define command entry, usually for modules.
+ * @param options The command options.
+ * @returns The entry of the command to deploy or register hooks.
+ * @example
+ * ```ts
+ * import { defineCommand } from "bakit";
+ *
+ * const command = defineCommand({
+ * 	name: "ping",
+ * 	description: "Displays bot's latency.",
+ * });
+ *
+ * command.main(async (context) => {
+ * 	await context.send(`Pong! ${context.client.ws.ping}ms!`);
+ * });
+ *
+ * export default command;
+ * ```
+ */
+declare function defineCommand<const ParamsList extends readonly AnyParam<any>[] = any[]>(options: (Omit<CommandOptionsInput, "params"> & {
+    params?: ParamsList;
+}) | string): Command<ParamsList>;
+
+declare class CommandManager extends BaseClientManager {
+    commands: Collection<string, Command<any[]>>;
+    loadModules(): Promise<Command[]>;
+    add(command: Command): void;
+    remove(target: string | Command): Command | undefined;
+    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"> & {
+    name: 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 {
+    listeners: Listener[];
+    private executors;
+    loadModules(): Promise<Listener[]>;
+    add(listener: Listener): void;
+    remove(target: string | Listener): Listener[];
+    getBaseIntents(): IntentsBitField;
+    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 loadModules;
+    private initIntents;
+}
+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, instance: Instance);
+    /**
+     * Check if the client is connected to gateway successfully and finished initialization.
+     */
+    isReady(): this is BakitClient<true>;
+    on<K extends keyof BakitClientEvents>(event: K, listener: (...args: BakitClientEvents[K]) => void): this;
+    once<K extends keyof BakitClientEvents>(event: K, listener: (...args: BakitClientEvents[K]) => void): this;
+    off<K extends keyof BakitClientEvents>(event: K, listener: (...args: BakitClientEvents[K]) => void): this;
+    removeAllListeners(event?: keyof BakitClientEvents): this;
+    removeListener<K extends keyof BakitClientEvents>(event: K, listener: (...args: BakitClientEvents[K]) => void): this;
+    emit<K extends keyof BakitClientEvents>(event: K, ...args: BakitClientEvents[K]): boolean;
+    /**
+     * Override BakitClient output when using logger for security concern.
+     * @returns `BakitClient {}`
+     */
+    [inspect.custom](): string;
+}
+
+declare class BaseClientManager {
+    client: BakitClient;
+    constructor(client: BakitClient);
+}
+
+declare const Params: {
+    readonly string: <Required extends boolean = true>(options: string | {
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+        maxLength?: number | undefined;
+        minLength?: number | undefined;
+    }) => StringParam<Required>;
+    readonly number: <Required extends boolean = true>(options: string | {
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+        maxValue?: number | undefined;
+        minValue?: number | undefined;
+    }) => NumberParam<Required>;
+};
+
+declare class BakitError extends Error {
+    constructor(message: string);
+}
 
-declare module "discord.js" {
-	interface Base {
-		client: BakitClient<true>;
-	}
+declare class ArgumentError extends BakitError {
+    target: string;
+    reason: string;
+    constructor(target: string, reason: string);
 }
 
-export { BakitClient, type ErrorListenerHookMethod, type EventsLike, Listener, ListenerAPI, ListenerEntry, type ListenerEntryOptions, ListenerFactory, type ListenerHook, ListenerRegistry, type MainListenerHookMethod, StateBox, type States, extractId };
+export { $jiti, type AnyParam, ArgumentError, BakitClient, type BakitClientEvents, BakitError, BaseClientManager, BaseCommandContext, BaseParam, type BaseParamOptions, BaseParamSchema, ChatInputContext, type ChatInputContextSendOptions, Command, type CommandContext, CommandManager, type CommandOptions, type CommandOptionsInput, CommandOptionsSchema, Context, type ContextSendOptions, EVENT_INTENT_MAPPING, type ErrorHookCallback, type GetPrefixFunction, HookOrder, HookState, type InferParamTuple, type InferParamValue, Instance, LifecycleManager, Listener, ListenerManager, type ListenerOptions, ListenerOptionsSchema, type MainHookCallback, MessageContext, type MessageContextSendOptions, type NumberOptions, NumberParam, NumberParamSchema, type ParamResolvedOutputType, ParamUserType, Params, type ProjectConfig, type ProjectConfigInput, ProjectConfigSchema, type StringOptions, StringParam, StringParamSchema, type UserOptions, UserParam, UserParamSchema, defineCommand, defineConfig, defineListener, extractSnowflakeId, getConfig, loadConfig, tokenize, useApp, validateParamsOrder };