vimcord 1.0.35 → 1.0.37

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 import * as discord_js from 'discord.js';
-import { SlashCommandBuilder as SlashCommandBuilder$1, SlashCommandOptionsOnlyBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandsOnlyBuilder, SlashCommandSubcommandGroupBuilder, PermissionResolvable, ActivityType, ContextMenuCommandBuilder, ChatInputCommandInteraction, ClientEvents, CommandInteraction, RepliableInteraction, TextBasedChannel, Message, GuildMember, User, EmbedBuilder, DMChannel, TextChannel, NewsChannel, ThreadChannel, ColorResolvable, ButtonComponentData, APIThumbnailComponent, ActionRowBuilder, MessageActionRowComponentBuilder, ContainerBuilder, BaseMessageOptions, StickerResolvable, PollData, InteractionReplyOptions, MessageMentionOptions, ReplyOptions, ForwardOptions, Client, APIEmbedField, APIEmbed, ClientOptions, Guild, ContextMenuCommandInteraction, MessageComponentType, UserResolvable as UserResolvable$1, MappedInteractionTypes, InteractionCollector, APITextInputComponent, APIStringSelectComponent, APIChannelSelectComponent, APIUserSelectComponent, APIRoleSelectComponent, APIMentionableSelectComponent, APIFileUploadComponent, AwaitModalSubmitOptions, ModalSubmitInteraction, InteractionDeferUpdateOptions, InteractionResponse, APIModalInteractionResponseCallbackData, ModalBuilder, Interaction, AttachmentBuilder, SelectMenuComponentOptionData, StringSelectMenuOptionBuilder, StringSelectMenuInteraction, ButtonInteraction, MessageReaction, StringSelectMenuBuilder, ButtonBuilder, ReactionCollector, APIButtonComponent, ChannelType, PartialGroupDMChannel, PartialDMChannel, GuildBasedChannel, AnyThreadChannel, VoiceBasedChannel, CategoryChannel, Channel, Role, GuildTextBasedChannel } from 'discord.js';
-import { DotenvConfigOptions } from 'dotenv';
-import * as mongoose from 'mongoose';
-import mongoose__default, { ClientSessionOptions, Connection, Schema, Model, SchemaDefinition, mongo, ClientSession, Require_id, RootFilterQuery, MongooseBaseQueryOptions, CreateOptions, QueryOptions, ProjectionType, HydratedDocument, UpdateQuery, MongooseUpdateQueryOptions, PipelineStage, AggregateOptions } from 'mongoose';
+import { SlashCommandBuilder as SlashCommandBuilder$1, SlashCommandOptionsOnlyBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandsOnlyBuilder, SlashCommandSubcommandGroupBuilder, PermissionResolvable, ChatInputCommandInteraction, Message, ContextMenuCommandInteraction, ContextMenuCommandBuilder, ClientEvents, ActivityType, Guild, CommandInteraction, ColorResolvable, ButtonComponentData, APIThumbnailComponent, ActionRowBuilder, MessageActionRowComponentBuilder, ContainerBuilder, BaseMessageOptions, StickerResolvable, PollData, InteractionReplyOptions, MessageMentionOptions, ReplyOptions, ForwardOptions, Client, TextBasedChannel, GuildMember, User, APIEmbedField, APIEmbed, EmbedBuilder, RepliableInteraction, DMChannel, TextChannel, NewsChannel, ThreadChannel, ClientOptions, MessageComponentType, InteractionCollector, MappedInteractionTypes, UserResolvable as UserResolvable$1, AwaitModalSubmitOptions, ModalSubmitInteraction, APIChannelSelectComponent, APIFileUploadComponent, APIMentionableSelectComponent, APITextInputComponent, APIStringSelectComponent, APIUserSelectComponent, APIRoleSelectComponent, APIModalInteractionResponseCallbackData, ModalBuilder, Interaction, InteractionDeferUpdateOptions, InteractionResponse, MessagePayload, AttachmentBuilder, SelectMenuComponentOptionData, StringSelectMenuOptionBuilder, StringSelectMenuInteraction, ButtonInteraction, MessageReaction, ButtonBuilder, StringSelectMenuBuilder, ReactionCollector, APIButtonComponent, ChannelType, PartialGroupDMChannel, PartialDMChannel, GuildBasedChannel, AnyThreadChannel, VoiceBasedChannel, CategoryChannel, Channel, Role, GuildTextBasedChannel } from 'discord.js';
 import { PartialDeep } from 'type-fest';
 import EventEmitter from 'node:events';
 import { Loop } from 'qznt';
+import * as mongoose from 'mongoose';
+import mongoose__default, { ClientSessionOptions, Connection, QueryOptions, HydratedDocument, Require_id, Schema, Model, SchemaDefinition, mongo, ClientSession, RootFilterQuery, MongooseBaseQueryOptions, CreateOptions, Document, ProjectionType, UpdateQuery, MongooseUpdateQueryOptions, PipelineStage, AggregateOptions, AnyBulkWriteOperation, MongooseBulkWriteOptions } from 'mongoose';
+import { DotenvConfigOptions } from 'dotenv';
 import { Interface } from 'node:readline';
 
 type AnySlashCommandBuilder = SlashCommandBuilder$1 | SlashCommandOptionsOnlyBuilder | SlashCommandSubcommandBuilder | SlashCommandSubcommandsOnlyBuilder | SlashCommandSubcommandGroupBuilder;
@@ -77,258 +77,92 @@ interface CommandPermissionResults {
     blacklistedRole?: string;
 }
 
-interface MongoConnectionOptions {
-    /** The maximum number of attempts to connect to MongoDB @defaultValue `3` */
-    maxRetries?: number;
-}
-declare class MongoDatabase {
-    private static instances;
-    private static emitter;
-    readonly moduleName = "MongoDatabase";
-    readonly clientId: number;
-    readonly client: Vimcord;
-    readonly mongoose: mongoose__default.Mongoose;
-    private isConnecting;
-    /**
-     * Returns an instance of MongoDatabase.
-     * @param clientId [default: 0]
-     */
-    static getInstance(clientId?: number | Vimcord): MongoDatabase | undefined;
-    /**
-     * Waits for a MongoDatabase instance to be ready. First waiting for the instance to initialize if it doesn't exist.
-     * @param clientId [default: 0]
-     * @param timeoutMs [default: 60000]
-     */
-    static getReadyInstance(clientId?: number | Vimcord, timeoutMs?: number): Promise<MongoDatabase>;
-    /**
-     * Starts a new Mongo client session.
-     * @param options Options for the new session
-     * @param clientId [default: 0]
-     */
-    static startSession(options?: ClientSessionOptions, clientId?: number | Vimcord): Promise<mongoose__default.mongo.ClientSession>;
-    constructor(client: Vimcord, options?: mongoose__default.MongooseOptions);
-    get connection(): Connection;
-    get isReady(): boolean;
-    waitForReady(): Promise<this>;
-    connect(uri?: string, connectionOptions?: mongoose__default.ConnectOptions, options?: MongoConnectionOptions): Promise<boolean>;
-    disconnect(): Promise<void>;
-    startSession(options?: ClientSessionOptions): Promise<mongoose__default.mongo.ClientSession>;
-    useTransaction(fn: (session: mongoose__default.ClientSession) => Promise<void>): Promise<void>;
-}
-
-type DatabaseManager = MongoDatabase;
-
-interface VimcordAppConfig {
-    devMode: boolean;
-    name: string;
-    appVersion: string;
-    /** Enable verbose console logs?
-     * @defaultValue false */
-    verbose: boolean;
-    /** Disable the vimcord client banner on startup
-     * @defaultValue false */
-    disableBanner: boolean;
-    /** Only auto import modules that end with these suffixes */
-    moduleSuffixes: {
-        /** @defaultValue slash */
-        slashCommand: "slash";
-        /** @defaultValue ctx */
-        contextCommand: "ctx";
-        /** @defaultValue prefix */
-        prefixCommand: "prefix";
-        /** @defaultValue event */
-        event: "event";
-    };
-}
-declare function createVimcordAppConfig(options?: PartialDeep<VimcordAppConfig>): VimcordAppConfig;
-
-interface VimcordStaffConfig {
-    ownerId: string | null;
-    superUsers: string[];
-    superUserRoles: string[];
-    bypassers: {
-        commandName: string;
-        userIds: string[];
-    }[];
-    bypassesGuildAdmin: {
-        allBotStaff: boolean;
-        botOwner: boolean;
-        superUsers: boolean;
-        bypassers: boolean;
-    };
-    guild: {
-        id: string | null;
-        inviteUrl: string | null;
-        channels: Record<string, string>;
-    };
-}
-declare function createVimcordStaffConfig(options?: PartialDeep<VimcordStaffConfig>): VimcordStaffConfig;
-
-interface VimcordSlashCommandConfig extends BaseCommandConfig<CommandType.Slash> {
-}
-declare function createVimcordSlashCommandConfig(options?: PartialDeep<VimcordSlashCommandConfig>): VimcordSlashCommandConfig;
-
-interface VimcordPrefixCommandConfig extends BaseCommandConfig<CommandType.Prefix> {
-    /** @defaultValue ! */
-    defaultPrefix: string;
-    /** @defaultValue true */
-    allowMentionAsPrefix: boolean;
-    /** @defaultValue true */
-    allowCaseInsensitiveCommandNames: boolean;
-    /**
-     * A custom resolver to fetch a guild-specific prefix.
-     * Returns a string (the prefix) or null/undefined to fallback to default.
-     */
-    guildPrefixResolver?: (client: Vimcord, guildId: string) => Promise<string | null | undefined> | string | null | undefined;
-}
-declare function createVimcordPrefixCommandConfig(options?: PartialDeep<VimcordPrefixCommandConfig>): VimcordPrefixCommandConfig;
-
-interface VimcordContextCommandConfig extends BaseCommandConfig<CommandType.Context> {
-}
-declare function createVimcordContextCommandConfig(options?: PartialDeep<VimcordContextCommandConfig>): VimcordContextCommandConfig;
-
-interface LoggerOptions {
-    colors?: Partial<typeof LOGGER_COLORS>;
-    prefix?: string | null;
-    prefixEmoji?: string | null;
-    minLevel?: LogLevel;
-    /** @defaultValue `true` */
-    showTimestamp?: boolean;
-}
-declare enum LogLevel {
-    DEBUG = 0,
-    INFO = 1,
-    SUCCESS = 2,
-    WARN = 3,
-    ERROR = 4
-}
-declare const LOGGER_COLORS: {
-    primary: string;
-    success: string;
-    warn: string;
-    danger: string;
-    muted: string;
-    text: string;
-};
-/** Reusable functions for using `console.log()`, but in 4k ultra HD retrocolor */
-declare class Logger {
-    private logPrefixEmoji;
-    private logPrefix;
-    private minLevel;
-    private showTimestamp;
-    private colorScheme;
-    constructor(options?: LoggerOptions);
-    protected formatTimestamp(): string;
-    protected formatPrefix(): string;
-    protected shouldLog(level: LogLevel): boolean;
-    get prefixEmoji(): string | null;
-    get prefix(): string | null;
-    get colors(): {
-        primary: string;
-        success: string;
-        warn: string;
-        danger: string;
-        muted: string;
-        text: string;
-    };
-    extend<Extra extends Record<string, (...args: any) => void>>(extras: Extra & ThisType<Logger>): Logger & Extra;
-    setPrefix(prefix: string | null): this;
-    setPrefixEmoji(prefixEmoji: string | null): this;
-    setMinLevel(minLevel: LogLevel): this;
-    setShowTimestamp(show: boolean): this;
-    setColors(colors: Partial<typeof LOGGER_COLORS>): this;
-    log(message: string, ...args: any[]): void;
-    debug(message: string, ...args: any[]): void;
-    info(message: string, ...args: any[]): void;
-    success(message: string, ...args: any[]): void;
-    warn(message: string, ...args: any[]): void;
-    error(message: string, error?: Error, ...args: any[]): void;
-    loader(message: string): (newMessage?: string) => void;
-    table(title: string, data: Record<string, any>): void;
-    section(title: string): void;
+declare enum CommandType {
+    Slash = 0,
+    Prefix = 1,
+    Context = 2
 }
-declare const logger: Logger;
-
-declare enum StatusType {
-    DND = "dnd",
-    Idle = "idle",
-    Online = "online",
-    Invisible = "invisible"
+declare enum MissingPermissionReason {
+    User = 0,
+    Bot = 1,
+    Role = 2,
+    UserBlacklisted = 3,
+    RoleBlacklisted = 4,
+    NotInGuild = 5,
+    NotGuildOwner = 6,
+    NotBotOwner = 7,
+    NotBotStaff = 8
 }
-interface ClientActivity {
-    /** Mappings:
-     * - `$USER_COUNT` - this.client.users.cache.size
-     * - `$GUILD_COUNT` - this.client.guilds.cache.size
-     * - `$STAFF_GUILD_MEMBER_COUNT` - self explanatory
-     */
-    name: string;
-    type: ActivityType;
-    status: StatusType;
-    streamUrl?: string;
+declare enum RateLimitScope {
+    User = 0,
+    Guild = 1,
+    Channel = 2,
+    Global = 3
 }
-interface ClientStatus {
-    /** In seconds */
-    interval?: number;
-    randomize?: boolean;
-    activity: ClientActivity | ClientActivity[];
+type BaseCommandParameters<T extends CommandType> = T extends CommandType.Slash ? [client: Vimcord<true>, interaction: ChatInputCommandInteraction] : T extends CommandType.Prefix ? [client: Vimcord<true>, message: Message] : T extends CommandType.Context ? [client: Vimcord<true>, interaction: ContextMenuCommandInteraction] : never;
+interface BaseCommandConfig<T extends CommandType> {
+    /** Is this command enabled? @defaultValue true */
+    enabled?: boolean;
+    /** Custom conditions that must be met for this command to execute */
+    conditions?: Array<(...args: BaseCommandParameters<T>) => boolean | Promise<boolean>>;
+    /** Command permission requirements */
+    permissions?: CommandPermissions;
+    /** Command metadata configuration */
+    metadata?: CommandMetadata;
+    /** Rate limiting options */
+    rateLimit?: CommandRateLimitOptions<(...args: BaseCommandParameters<T>) => any>;
+    /** Log whenever a command is executed? @defaultValue true */
+    logExecution?: boolean;
+    /** Executed before the main command logic */
+    beforeExecute?: (...args: BaseCommandParameters<T>) => any;
+    /** The main command function that will be executed */
+    execute?: (...args: BaseCommandParameters<T>) => any;
+    /** Executed after successful execution */
+    afterExecute?: (result: any, ...args: BaseCommandParameters<T>) => any;
+    /** Executed when the required permissions are not met */
+    onMissingPermissions?: (results: CommandPermissionResults, ...args: BaseCommandParameters<T>) => any;
+    /** Executed when the required conditions are not met */
+    onConditionsNotMet?: (...args: BaseCommandParameters<T>) => any;
+    /** Executed when this command is used when its disabled */
+    onUsedWhenDisabled?: (...args: BaseCommandParameters<T>) => any;
+    /** Executed when the rate limit is hit */
+    onRateLimit?: (...args: BaseCommandParameters<T>) => any;
+    /** Custom error handler */
+    onError?: (error: Error, ...args: BaseCommandParameters<T>) => any;
 }
-interface VimcordClientStatus {
-    production: ClientStatus;
-    development: ClientStatus;
+interface BaseAppCommandConfig {
+    /** Command deployment configuration */
+    deployment?: AppCommandDeployment;
 }
-declare function createVimcordStatusConfig(options?: PartialDeep<VimcordClientStatus>): VimcordClientStatus;
-
-type StatusManagerEvents = {
-    changed: [ClientActivity];
-    cleared: [];
-    rotation: [ClientActivity];
-    paused: [Loop];
-    started: [Loop];
-    destroyed: [];
-};
-declare class StatusManager {
-    client: Vimcord;
-    logger: Logger;
-    emitter: EventEmitter<StatusManagerEvents>;
-    lastActivity: ClientActivity | null;
-    lastActivityIndex: number;
-    private task;
-    constructor(client: Vimcord);
-    private clearData;
-    private getReadyClient;
-    private formatActivityName;
-    private setActivity;
-    private statusRotationTask;
-    private scheduleStatusRotation;
-    start(): this;
-    pause(): this;
-    set(status: PartialDeep<VimcordClientStatus>): Promise<this>;
-    destroy(): Promise<this>;
-    clear(): Promise<this>;
+interface CommandInternalRateLimitData {
+    /** Number of times executed */
+    executions: number;
+    /** Timestamp of latest execution */
+    timestamp: number;
 }
 
-interface ContextCommandConfig extends BaseCommandConfig<CommandType.Context>, BaseAppCommandConfig {
+interface _ContextCommandConfig extends BaseCommandConfig<CommandType.Context>, BaseAppCommandConfig {
     builder: ContextMenuCommandBuilder | ((builder: ContextMenuCommandBuilder) => ContextMenuCommandBuilder);
     deferReply?: boolean | {
         ephemeral?: boolean;
     };
 }
-declare class ContextCommandBuilder extends BaseCommandBuilder<CommandType.Context, ContextCommandConfig> {
+declare class ContextCommandBuilder extends BaseCommandBuilder<CommandType.Context, _ContextCommandConfig> {
     builder: ContextMenuCommandBuilder;
-    constructor(config: ContextCommandConfig);
+    constructor(config: _ContextCommandConfig);
     private handleExecution;
     private validateBuilder;
-    setBuilder(builder: ContextCommandConfig["builder"]): this;
-    setDeferReply(defer: ContextCommandConfig["deferReply"]): this;
+    setBuilder(builder: _ContextCommandConfig["builder"]): this;
+    setDeferReply(defer: _ContextCommandConfig["deferReply"]): this;
     setDeployment(deployment: AppCommandDeployment): this;
-    setExecute(fn: ContextCommandConfig["execute"]): this;
-    toConfig(): ContextCommandConfig;
+    setExecute(fn: _ContextCommandConfig["execute"]): this;
+    toConfig(): _ContextCommandConfig;
 }
 
 /**
  * Configuration specific to Prefix-based commands
  */
-interface PrefixCommandConfig extends BaseCommandConfig<CommandType.Prefix> {
+interface _PrefixCommandConfig extends BaseCommandConfig<CommandType.Prefix> {
     /** The primary name of the command */
     name: string;
     /** Alternative triggers for this command */
@@ -336,9 +170,9 @@ interface PrefixCommandConfig extends BaseCommandConfig<CommandType.Prefix> {
     /** A brief explanation of what the command does */
     description?: string;
 }
-declare class PrefixCommandBuilder extends BaseCommandBuilder<CommandType.Prefix, PrefixCommandConfig> {
-    options: PrefixCommandConfig;
-    constructor(options: PrefixCommandConfig);
+declare class PrefixCommandBuilder extends BaseCommandBuilder<CommandType.Prefix, _PrefixCommandConfig> {
+    options: _PrefixCommandConfig;
+    constructor(options: _PrefixCommandConfig);
     /**
      * Specialized execution logic for Prefix Commands.
      */
@@ -364,14 +198,14 @@ declare class PrefixCommandBuilder extends BaseCommandBuilder<CommandType.Prefix
      * Override setExecute to ensure handleExecution remains the entry point.
      * This is the only base method we need to redefine.
      */
-    setExecute(fn: PrefixCommandConfig["execute"]): this;
+    setExecute(fn: _PrefixCommandConfig["execute"]): this;
     /**
      * Converts the current builder state back into a config object.
      */
-    toConfig(): PrefixCommandConfig;
+    toConfig(): _PrefixCommandConfig;
 }
 
-interface SlashCommandConfig extends BaseCommandConfig<CommandType.Slash>, BaseAppCommandConfig {
+interface _SlashCommandConfig extends BaseCommandConfig<CommandType.Slash>, BaseAppCommandConfig {
     builder: AnySlashCommandBuilder | ((builder: SlashCommandBuilder$1) => AnySlashCommandBuilder);
     deferReply?: boolean | {
         ephemeral?: boolean;
@@ -382,24 +216,34 @@ interface SlashCommandConfig extends BaseCommandConfig<CommandType.Slash>, BaseA
     }>;
     onUnknownRouteHandler?: (client: Vimcord<true>, interaction: ChatInputCommandInteraction) => any;
 }
-declare class SlashCommandBuilder extends BaseCommandBuilder<CommandType.Slash, SlashCommandConfig> {
+declare class SlashCommandBuilder extends BaseCommandBuilder<CommandType.Slash, _SlashCommandConfig> {
     builder: AnySlashCommandBuilder;
     readonly routes: Map<string, (client: Vimcord<true>, interaction: ChatInputCommandInteraction) => any>;
-    constructor(config: SlashCommandConfig);
+    constructor(config: _SlashCommandConfig);
     private handleExecution;
     private validateBuilder;
-    setBuilder(builder: SlashCommandConfig["builder"]): this;
-    setDeferReply(defer: SlashCommandConfig["deferReply"]): this;
+    setBuilder(builder: _SlashCommandConfig["builder"]): this;
+    setDeferReply(defer: _SlashCommandConfig["deferReply"]): this;
     setDeployment(deployment: AppCommandDeployment): this;
-    setRoutes(...routes: NonNullable<SlashCommandConfig["routes"]>): this;
-    addRoutes(...routes: NonNullable<SlashCommandConfig["routes"]>): this;
-    setUnknownRouteHandler(handler: SlashCommandConfig["onUnknownRouteHandler"]): this;
-    setExecute(fn: SlashCommandConfig["execute"]): this;
-    toConfig(): SlashCommandConfig;
+    setRoutes(...routes: NonNullable<_SlashCommandConfig["routes"]>): this;
+    addRoutes(...routes: NonNullable<_SlashCommandConfig["routes"]>): this;
+    setUnknownRouteHandler(handler: _SlashCommandConfig["onUnknownRouteHandler"]): this;
+    setExecute(fn: _SlashCommandConfig["execute"]): this;
+    toConfig(): _SlashCommandConfig;
 }
 
 type VimcordCommandBuilderByType<T extends CommandType> = T extends CommandType.Slash ? SlashCommandBuilder : T extends CommandType.Context ? ContextCommandBuilder : T extends CommandType.Prefix ? PrefixCommandBuilder : never;
 
+declare abstract class ModuleImporter<T> {
+    readonly client: Vimcord;
+    abstract readonly items: Map<string, T>;
+    abstract readonly itemSuffix: string | undefined;
+    abstract readonly itemName: string;
+    constructor(client: Vimcord);
+    importFrom(dir: string | string[], set?: boolean, suffix?: string | string[] | null): Promise<Map<string, T>>;
+    protected abstract getName(module: T): string;
+}
+
 interface CommandFilter {
     names?: string[];
     fuzzyNames?: string[];
@@ -411,12 +255,14 @@ interface CommandByCategory<T extends CommandType> {
     emoji: string | undefined;
     commands: VimcordCommandBuilderByType<T>[];
 }
-declare class BaseCommandManager<T extends CommandType> {
+declare class BaseCommandManager<T extends CommandType> extends ModuleImporter<VimcordCommandBuilderByType<T>> {
     readonly type: T;
-    readonly client: Vimcord;
-    readonly commands: Map<string, VimcordCommandBuilderByType<T>>;
-    readonly moduleSuffix?: string;
-    constructor(client: Vimcord, type: T, moduleSuffix?: string);
+    readonly items: Map<string, VimcordCommandBuilderByType<T>>;
+    readonly itemSuffix: string | undefined;
+    constructor(client: Vimcord, type: T, itemSuffix?: string);
+    get commands(): Map<string, VimcordCommandBuilderByType<T>>;
+    get itemName(): string;
+    protected getName(module: VimcordCommandBuilderByType<T>): string;
     /**
      * Gets a command by name.
      */
@@ -429,12 +275,6 @@ declare class BaseCommandManager<T extends CommandType> {
      * Groups commands by category alphabetically.
      */
     sortByCategory(): CommandByCategory<T>[];
-    /**
-     * Imports command modules from a directory.
-     * @param dir Path of one or more folders.
-     * @param set Replaces imported command modules with the ones found.
-     */
-    importFrom(dir: string | string[], set?: boolean): Promise<Map<string, VimcordCommandBuilderByType<T>>>;
 }
 declare class SlashCommandManager extends BaseCommandManager<CommandType.Slash> {
     constructor(client: Vimcord);
@@ -451,7 +291,7 @@ declare class CommandManager {
     readonly prefix: PrefixCommandManager;
     readonly context: ContextCommandManager;
     constructor(client: Vimcord);
-    getAllAppCommands(options?: CommandFilter): (SlashCommandBuilder | ContextCommandBuilder)[];
+    getAllAppCommands(options?: CommandFilter): (ContextCommandBuilder | SlashCommandBuilder)[];
     registerGlobal(options?: CommandFilter): Promise<void>;
     unregisterGlobal(): Promise<void>;
     registerGuild(options?: CommandFilter & {
@@ -462,6 +302,68 @@ declare class CommandManager {
     }): Promise<void>;
 }
 
+interface LoggerOptions {
+    colors?: Partial<typeof LOGGER_COLORS>;
+    prefix?: string | null;
+    prefixEmoji?: string | null;
+    minLevel?: LogLevel;
+    /** @defaultValue `true` */
+    showTimestamp?: boolean;
+}
+declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    SUCCESS = 2,
+    WARN = 3,
+    ERROR = 4
+}
+declare const LOGGER_COLORS: {
+    primary: string;
+    success: string;
+    warn: string;
+    danger: string;
+    muted: string;
+    text: string;
+};
+/** Reusable functions for using `console.log()`, but in 4k ultra HD retrocolor */
+declare class Logger {
+    private logPrefixEmoji;
+    private logPrefix;
+    private minLevel;
+    private showTimestamp;
+    private colorScheme;
+    constructor(options?: LoggerOptions);
+    protected formatTimestamp(): string;
+    protected formatPrefix(): string;
+    protected shouldLog(level: LogLevel): boolean;
+    get prefixEmoji(): string | null;
+    get prefix(): string | null;
+    get colors(): {
+        primary: string;
+        success: string;
+        warn: string;
+        danger: string;
+        muted: string;
+        text: string;
+    };
+    extend<Extra extends Record<string, (...args: any) => void>>(extras: Extra & ThisType<Logger>): Logger & Extra;
+    setPrefix(prefix: string | null): this;
+    setPrefixEmoji(prefixEmoji: string | null): this;
+    setMinLevel(minLevel: LogLevel): this;
+    setShowTimestamp(show: boolean): this;
+    setColors(colors: Partial<typeof LOGGER_COLORS>): this;
+    log(message: string, ...args: any[]): void;
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    success(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, error?: Error, ...args: any[]): void;
+    loader(message: string): (newMessage?: string) => void;
+    table(title: string, data: Record<string, any>): void;
+    section(title: string): void;
+}
+declare const logger: Logger;
+
 type EventParameters<T extends keyof ClientEvents> = [client: Vimcord<true>, ...args: ClientEvents[T]];
 
 interface EventMetadata {
@@ -560,11 +462,13 @@ declare class EventBuilder<T extends keyof ClientEvents = keyof ClientEvents> im
     executeEvent(...args: EventParameters<T>): Promise<any>;
 }
 
-declare class EventManager {
-    client: Vimcord;
-    events: Map<string, EventBuilder<any>>;
+declare class EventManager extends ModuleImporter<EventBuilder<any>> {
+    readonly items: Map<string, EventBuilder<any>>;
+    readonly itemSuffix = "event";
+    readonly itemName = "Event Handlers";
     logger: Logger;
     constructor(client: Vimcord);
+    protected getName(module: EventBuilder<any>): string;
     register<T extends keyof ClientEvents>(...events: EventBuilder<T>[]): void;
     unregister(...names: string[]): void;
     clear(): void;
@@ -573,27 +477,362 @@ declare class EventManager {
     getByCategory(category: string): EventBuilder[];
     getByEvent<T extends keyof ClientEvents>(eventType: T): EventBuilder<T>[];
     executeEvents<T extends keyof ClientEvents>(eventType: T, ...args: ClientEvents[T]): Promise<void>;
-    /** Import event modules that end with `.event` */
-    importFrom(dir: string | string[], replaceAll?: boolean): Promise<Map<string, EventBuilder<any>>>;
 }
 
-declare enum SendMethod {
-    Reply = 0,
-    EditReply = 1,
-    FollowUp = 2,
-    Channel = 3,
-    MessageReply = 4,
-    MessageEdit = 5,
-    User = 6
+declare enum StatusType {
+    DND = "dnd",
+    Idle = "idle",
+    Online = "online",
+    Invisible = "invisible"
+}
+interface ClientActivity {
+    /** Mappings:
+     * - `$USER_COUNT` - this.client.users.cache.size
+     * - `$GUILD_COUNT` - this.client.guilds.cache.size
+     * - `$STAFF_GUILD_MEMBER_COUNT` - self explanatory
+     */
+    name: string;
+    type: ActivityType;
+    status: StatusType;
+    streamUrl?: string;
+}
+interface ClientStatus {
+    /** In seconds */
+    interval?: number;
+    randomize?: boolean;
+    activity: ClientActivity | ClientActivity[];
+}
+interface VimcordClientStatus {
+    production: ClientStatus;
+    development: ClientStatus;
+}
+declare function createVimcordStatusConfig(options?: PartialDeep<VimcordClientStatus>): VimcordClientStatus;
+
+type StatusManagerEvents = {
+    changed: [ClientActivity];
+    cleared: [];
+    rotation: [ClientActivity];
+    paused: [Loop];
+    started: [Loop];
+    destroyed: [];
+};
+declare class StatusManager {
+    client: Vimcord;
+    logger: Logger;
+    emitter: EventEmitter<StatusManagerEvents>;
+    lastActivity: ClientActivity | null;
+    lastActivityIndex: number;
+    private task;
+    constructor(client: Vimcord);
+    private clearData;
+    private getReadyClient;
+    private formatActivityName;
+    private setActivity;
+    private statusRotationTask;
+    private scheduleStatusRotation;
+    start(): this;
+    pause(): this;
+    set(status: PartialDeep<VimcordClientStatus>): Promise<this>;
+    destroy(): Promise<this>;
+    clear(): Promise<this>;
+}
+
+interface MongoConnectionOptions {
+    /** The maximum number of attempts to connect to MongoDB @defaultValue `3` */
+    maxRetries?: number;
+}
+declare class MongoDatabase {
+    private static instances;
+    private static emitter;
+    readonly moduleName = "MongoDatabase";
+    readonly clientId: number;
+    readonly client: Vimcord;
+    readonly mongoose: mongoose__default.Mongoose;
+    private isConnecting;
+    /**
+     * Returns an instance of MongoDatabase.
+     * @param clientId [default: 0]
+     */
+    static getInstance(clientId?: number | Vimcord): MongoDatabase | undefined;
+    /**
+     * Waits for a MongoDatabase instance to be ready. First waiting for the instance to initialize if it doesn't exist.
+     * @param clientId [default: 0]
+     * @param timeoutMs [default: 60000]
+     */
+    static getReadyInstance(clientId?: number | Vimcord, timeoutMs?: number): Promise<MongoDatabase>;
+    /**
+     * Starts a new Mongo client session.
+     * @param options Options for the new session
+     * @param clientId [default: 0]
+     */
+    static startSession(options?: ClientSessionOptions, clientId?: number | Vimcord): Promise<mongoose__default.mongo.ClientSession>;
+    constructor(client: Vimcord, options?: mongoose__default.MongooseOptions);
+    get connection(): Connection;
+    get isReady(): boolean;
+    waitForReady(): Promise<this>;
+    connect(uri?: string, connectionOptions?: mongoose__default.ConnectOptions, options?: MongoConnectionOptions): Promise<boolean>;
+    disconnect(): Promise<void>;
+    startSession(options?: ClientSessionOptions): Promise<mongoose__default.mongo.ClientSession>;
+    useTransaction(fn: (session: mongoose__default.ClientSession) => Promise<void>): Promise<void>;
+}
+
+type DatabaseManager = MongoDatabase;
+
+declare class ErrorHandler {
+    readonly client: Vimcord;
+    constructor(client: Vimcord);
+    /** Handles command errors - sends error embed to user, then rethrows. */
+    handleCommandError(error: Error, guild: Guild | null, messageOrInteraction: Message | CommandInteraction): Promise<void>;
+    /** Handles internal Vimcord errors - logs with [Vimcord] prefix. */
+    handleVimcordError(error: Error, context: string): void;
+    /** Sets up global process error handlers. */
+    setupGlobalHandlers(): void;
+}
+
+interface AppConfig {
+    /** The name of the bot displayed in logs and startup banner.
+     * @accessible via `client.$name` for use in embeds, error messages, etc.
+     */
+    name: string;
+    /** The current version of the bot displayed in logs and startup banner.
+     * @accessible via `client.$version` for version commands or update notifications.
+     * @defaultValue Extracted from your `package.json` version field. If not found, defaults to `1.0.0`.
+     */
+    version: string;
+    /** Enables development mode for testing and debugging.
+     *
+     * **The way it works:**
+     * - If the bot is ran with the `--dev` flag it will automatically be enabled
+     * - Can be changed during runtime using the `client.$devMode` setter
+     *
+     * **What this does by default:**
+     * - Automatically switches to `TOKEN_DEV` and `MONGO_URI_DEV` environment variables
+     *
+     * **Common use cases:**
+     * - Use a separate Discord server, bot account, or database for testing
+     * - Skip production-only behaviors like analytics tracking or email notifications
+     * - Enable additional debug commands or verbose logging
+     * - Switch between development and production API endpoints for your other services
+     *
+     * @accessible via `client.$devMode` to conditionally enable/disable your own features.
+     *
+     * @example
+     * ```ts
+     * // Use different API endpoints for your own services
+     * const baseAPIUrl = client.$devMode
+     *   ? 'http://localhost:3000'
+     *   : 'https://api.production.com';
+     * ```
+     */
+    devMode: boolean;
+    /** Enables verbose console logging with additional debug information.
+     * @accessible via `client.$verboseMode`
+     * @defaultValue false
+     */
+    verbose: boolean;
+    /** Enables the Vimcord CLI.
+     * @defaultValue false
+     */
+    enableCLI: boolean;
+    /** Disables the Vimcord ASCII art banner on startup.
+     * @defaultValue false
+     */
+    disableBanner: boolean;
+}
+declare const createAppConfig: (options?: {
+    name?: string | undefined;
+    version?: string | undefined;
+    devMode?: boolean | undefined;
+    verbose?: boolean | undefined;
+    enableCLI?: boolean | undefined;
+    disableBanner?: boolean | undefined;
+}, existing?: AppConfig | undefined) => AppConfig;
+
+interface ContextCommandConfig extends BaseCommandConfig<CommandType.Context> {
+}
+declare const createContextCommandConfig: (options?: {
+    enabled?: boolean | undefined;
+    conditions?: ((client: Vimcord<true>, interaction: discord_js.ContextMenuCommandInteraction<discord_js.CacheType>) => boolean | Promise<boolean>)[] | undefined;
+    permissions?: {
+        user?: discord_js.PermissionResolvable[] | undefined;
+        bot?: discord_js.PermissionResolvable[] | undefined;
+        roles?: string[] | undefined;
+        userWhitelist?: string[] | undefined;
+        userBlacklist?: string[] | undefined;
+        roleBlacklist?: string[] | undefined;
+        guildOnly?: boolean | undefined;
+        guildOwnerOnly?: boolean | undefined;
+        botOwnerOnly?: boolean | undefined;
+        botStaffOnly?: boolean | undefined;
+    } | undefined;
+    metadata?: {
+        category?: string | undefined;
+        categoryEmoji?: string | undefined;
+        tags?: string[] | undefined;
+        examples?: string[] | undefined;
+        emoji?: string | undefined;
+        hidden?: boolean | undefined;
+    } | undefined;
+    rateLimit?: {
+        max?: number | undefined;
+        interval?: number | undefined;
+        scope?: RateLimitScope | undefined;
+        onRateLimit?: ((client: Vimcord<true>, interaction: discord_js.ContextMenuCommandInteraction<discord_js.CacheType>) => any) | undefined;
+    } | undefined;
+    logExecution?: boolean | undefined;
+    beforeExecute?: ((client: Vimcord<true>, interaction: discord_js.ContextMenuCommandInteraction<discord_js.CacheType>) => any) | undefined;
+    execute?: ((client: Vimcord<true>, interaction: discord_js.ContextMenuCommandInteraction<discord_js.CacheType>) => any) | undefined;
+    afterExecute?: ((result: any, client: Vimcord<true>, interaction: discord_js.ContextMenuCommandInteraction<discord_js.CacheType>) => any) | undefined;
+    onMissingPermissions?: ((results: CommandPermissionResults, client: Vimcord<true>, interaction: discord_js.ContextMenuCommandInteraction<discord_js.CacheType>) => any) | undefined;
+    onConditionsNotMet?: ((client: Vimcord<true>, interaction: discord_js.ContextMenuCommandInteraction<discord_js.CacheType>) => any) | undefined;
+    onUsedWhenDisabled?: ((client: Vimcord<true>, interaction: discord_js.ContextMenuCommandInteraction<discord_js.CacheType>) => any) | undefined;
+    onRateLimit?: ((client: Vimcord<true>, interaction: discord_js.ContextMenuCommandInteraction<discord_js.CacheType>) => any) | undefined;
+    onError?: ((error: Error, client: Vimcord<true>, interaction: discord_js.ContextMenuCommandInteraction<discord_js.CacheType>) => any) | undefined;
+}, existing?: ContextCommandConfig | undefined) => ContextCommandConfig;
+
+interface PrefixCommandConfig extends BaseCommandConfig<CommandType.Prefix> {
+    /** @defaultValue ! */
+    defaultPrefix: string;
+    /** @defaultValue true */
+    allowMentionAsPrefix: boolean;
+    /** @defaultValue true */
+    allowCaseInsensitiveCommandNames: boolean;
+    /**
+     * A custom resolver to fetch a guild-specific prefix.
+     * Returns a string (the prefix) or null/undefined to fallback to default.
+     */
+    guildPrefixResolver?: (client: Vimcord, guildId: string) => Promise<string | null | undefined> | string | null | undefined;
+}
+declare const createPrefixCommandConfig: (options?: {
+    defaultPrefix?: string | undefined;
+    allowMentionAsPrefix?: boolean | undefined;
+    allowCaseInsensitiveCommandNames?: boolean | undefined;
+    guildPrefixResolver?: ((client: Vimcord, guildId: string) => Promise<string | null | undefined> | string | null | undefined) | undefined;
+    enabled?: boolean | undefined;
+    conditions?: ((client: Vimcord<true>, message: discord_js.Message<boolean>) => boolean | Promise<boolean>)[] | undefined;
+    permissions?: {
+        user?: discord_js.PermissionResolvable[] | undefined;
+        bot?: discord_js.PermissionResolvable[] | undefined;
+        roles?: string[] | undefined;
+        userWhitelist?: string[] | undefined;
+        userBlacklist?: string[] | undefined;
+        roleBlacklist?: string[] | undefined;
+        guildOnly?: boolean | undefined;
+        guildOwnerOnly?: boolean | undefined;
+        botOwnerOnly?: boolean | undefined;
+        botStaffOnly?: boolean | undefined;
+    } | undefined;
+    metadata?: {
+        category?: string | undefined;
+        categoryEmoji?: string | undefined;
+        tags?: string[] | undefined;
+        examples?: string[] | undefined;
+        emoji?: string | undefined;
+        hidden?: boolean | undefined;
+    } | undefined;
+    rateLimit?: {
+        max?: number | undefined;
+        interval?: number | undefined;
+        scope?: RateLimitScope | undefined;
+        onRateLimit?: ((client: Vimcord<true>, message: discord_js.Message<boolean>) => any) | undefined;
+    } | undefined;
+    logExecution?: boolean | undefined;
+    beforeExecute?: ((client: Vimcord<true>, message: discord_js.Message<boolean>) => any) | undefined;
+    execute?: ((client: Vimcord<true>, message: discord_js.Message<boolean>) => any) | undefined;
+    afterExecute?: ((result: any, client: Vimcord<true>, message: discord_js.Message<boolean>) => any) | undefined;
+    onMissingPermissions?: ((results: CommandPermissionResults, client: Vimcord<true>, message: discord_js.Message<boolean>) => any) | undefined;
+    onConditionsNotMet?: ((client: Vimcord<true>, message: discord_js.Message<boolean>) => any) | undefined;
+    onUsedWhenDisabled?: ((client: Vimcord<true>, message: discord_js.Message<boolean>) => any) | undefined;
+    onRateLimit?: ((client: Vimcord<true>, message: discord_js.Message<boolean>) => any) | undefined;
+    onError?: ((error: Error, client: Vimcord<true>, message: discord_js.Message<boolean>) => any) | undefined;
+}, existing?: PrefixCommandConfig | undefined) => PrefixCommandConfig;
+
+interface SlashCommandConfig extends BaseCommandConfig<CommandType.Slash> {
+}
+declare const createSlashCommandConfig: (options?: {
+    enabled?: boolean | undefined;
+    conditions?: ((client: Vimcord<true>, interaction: discord_js.ChatInputCommandInteraction<discord_js.CacheType>) => boolean | Promise<boolean>)[] | undefined;
+    permissions?: {
+        user?: discord_js.PermissionResolvable[] | undefined;
+        bot?: discord_js.PermissionResolvable[] | undefined;
+        roles?: string[] | undefined;
+        userWhitelist?: string[] | undefined;
+        userBlacklist?: string[] | undefined;
+        roleBlacklist?: string[] | undefined;
+        guildOnly?: boolean | undefined;
+        guildOwnerOnly?: boolean | undefined;
+        botOwnerOnly?: boolean | undefined;
+        botStaffOnly?: boolean | undefined;
+    } | undefined;
+    metadata?: {
+        category?: string | undefined;
+        categoryEmoji?: string | undefined;
+        tags?: string[] | undefined;
+        examples?: string[] | undefined;
+        emoji?: string | undefined;
+        hidden?: boolean | undefined;
+    } | undefined;
+    rateLimit?: {
+        max?: number | undefined;
+        interval?: number | undefined;
+        scope?: RateLimitScope | undefined;
+        onRateLimit?: ((client: Vimcord<true>, interaction: discord_js.ChatInputCommandInteraction<discord_js.CacheType>) => any) | undefined;
+    } | undefined;
+    logExecution?: boolean | undefined;
+    beforeExecute?: ((client: Vimcord<true>, interaction: discord_js.ChatInputCommandInteraction<discord_js.CacheType>) => any) | undefined;
+    execute?: ((client: Vimcord<true>, interaction: discord_js.ChatInputCommandInteraction<discord_js.CacheType>) => any) | undefined;
+    afterExecute?: ((result: any, client: Vimcord<true>, interaction: discord_js.ChatInputCommandInteraction<discord_js.CacheType>) => any) | undefined;
+    onMissingPermissions?: ((results: CommandPermissionResults, client: Vimcord<true>, interaction: discord_js.ChatInputCommandInteraction<discord_js.CacheType>) => any) | undefined;
+    onConditionsNotMet?: ((client: Vimcord<true>, interaction: discord_js.ChatInputCommandInteraction<discord_js.CacheType>) => any) | undefined;
+    onUsedWhenDisabled?: ((client: Vimcord<true>, interaction: discord_js.ChatInputCommandInteraction<discord_js.CacheType>) => any) | undefined;
+    onRateLimit?: ((client: Vimcord<true>, interaction: discord_js.ChatInputCommandInteraction<discord_js.CacheType>) => any) | undefined;
+    onError?: ((error: Error, client: Vimcord<true>, interaction: discord_js.ChatInputCommandInteraction<discord_js.CacheType>) => any) | undefined;
+}, existing?: SlashCommandConfig | undefined) => SlashCommandConfig;
+
+interface StaffConfig {
+    ownerId: string | null;
+    superUsers: string[];
+    superUserRoles: string[];
+    bypassers: {
+        commandName: string;
+        userIds: string[];
+    }[];
+    bypassesGuildAdmin: {
+        allBotStaff: boolean;
+        botOwner: boolean;
+        superUsers: boolean;
+        bypassers: boolean;
+    };
+    guild: {
+        id: string | null;
+        inviteUrl: string | null;
+        channels: Record<string, string>;
+    };
 }
-type SendHandler = CommandInteraction | RepliableInteraction | TextBasedChannel | Message | GuildMember | User;
-type InteractionBasedSendHandler = CommandInteraction | RepliableInteraction;
-type EmbedResolvable = EmbedBuilder | BetterEmbed;
-type InteractionResolveable = CommandInteraction | RepliableInteraction;
-type UserResolvable = GuildMember | User | string;
-type SendableTextChannel = DMChannel | TextChannel | NewsChannel | ThreadChannel;
+declare const createStaffConfig: (options?: {
+    ownerId?: string | null | undefined;
+    superUsers?: string[] | undefined;
+    superUserRoles?: string[] | undefined;
+    bypassers?: {
+        commandName: string;
+        userIds: string[];
+    }[] | undefined;
+    bypassesGuildAdmin?: {
+        allBotStaff?: boolean | undefined;
+        botOwner?: boolean | undefined;
+        superUsers?: boolean | undefined;
+        bypassers?: boolean | undefined;
+    } | undefined;
+    guild?: {
+        id?: string | null | undefined;
+        inviteUrl?: string | null | undefined;
+        channels?: {
+            [x: string]: string | undefined;
+        } | undefined;
+    } | undefined;
+}, existing?: StaffConfig | undefined) => StaffConfig;
 
-interface VimcordToolsConfig {
+interface ToolsConfig {
     devMode: boolean;
     embedColor: ColorResolvable[];
     embedColorDev: ColorResolvable[];
@@ -629,9 +868,8 @@ interface VimcordToolsConfig {
         rejectLabel: string;
     };
 }
-declare const globalVimcordToolsConfig: VimcordToolsConfig;
-declare function defineGlobalToolsConfig(options: PartialDeep<VimcordToolsConfig>): void;
-declare function createToolsConfig(options?: PartialDeep<VimcordToolsConfig>): VimcordToolsConfig & {
+declare const globalToolsConfig: ToolsConfig;
+declare const createToolsConfig: (options?: {
     devMode?: boolean | undefined;
     embedColor?: ColorResolvable[] | undefined;
     embedColorDev?: ColorResolvable[] | undefined;
@@ -660,7 +898,7 @@ declare function createToolsConfig(options?: PartialDeep<VimcordToolsConfig>): V
                     id?: string | undefined;
                 } | undefined;
             } | undefined;
-            back?: {
+            last?: {
                 label?: string | undefined;
                 emoji?: {
                     animated?: boolean | undefined;
@@ -668,7 +906,7 @@ declare function createToolsConfig(options?: PartialDeep<VimcordToolsConfig>): V
                     id?: string | undefined;
                 } | undefined;
             } | undefined;
-            jump?: {
+            back?: {
                 label?: string | undefined;
                 emoji?: {
                     animated?: boolean | undefined;
@@ -676,7 +914,7 @@ declare function createToolsConfig(options?: PartialDeep<VimcordToolsConfig>): V
                     id?: string | undefined;
                 } | undefined;
             } | undefined;
-            next?: {
+            jump?: {
                 label?: string | undefined;
                 emoji?: {
                     animated?: boolean | undefined;
@@ -684,7 +922,7 @@ declare function createToolsConfig(options?: PartialDeep<VimcordToolsConfig>): V
                     id?: string | undefined;
                 } | undefined;
             } | undefined;
-            last?: {
+            next?: {
                 label?: string | undefined;
                 emoji?: {
                     animated?: boolean | undefined;
@@ -700,11 +938,12 @@ declare function createToolsConfig(options?: PartialDeep<VimcordToolsConfig>): V
         confirmLabel?: string | undefined;
         rejectLabel?: string | undefined;
     } | undefined;
-};
+}, existing?: ToolsConfig | undefined) => ToolsConfig;
+declare const defineGlobalToolsConfig: (options: PartialDeep<ToolsConfig>) => void;
 
 interface BetterContainerData {
-    color?: string | string[] | null;
-    config?: VimcordToolsConfig;
+    color?: ColorResolvable | ColorResolvable[] | null;
+    config?: PartialDeep<ToolsConfig>;
 }
 declare class BetterContainer {
     private container;
@@ -713,6 +952,8 @@ declare class BetterContainer {
     constructor(data?: BetterContainerData);
     private configure;
     build(): void;
+    setColor(color: ColorResolvable | ColorResolvable[]): this;
+    clearColor(): this;
     addSeparator(options?: {
         divider?: boolean;
         spacing?: number;
@@ -827,7 +1068,7 @@ interface BetterEmbedData {
     color?: ColorResolvable | ColorResolvable[] | null;
     timestamp?: number | boolean | Date | null;
     acf?: boolean;
-    config?: VimcordToolsConfig;
+    config?: PartialDeep<ToolsConfig>;
 }
 declare class BetterEmbed {
     private embed;
@@ -881,30 +1122,82 @@ declare class BetterEmbed {
     send(handler: SendHandler, options?: DynaSendOptions, overrides?: Partial<BetterEmbedData>): Promise<Message | null>;
 }
 
-interface CommandErrorMessageConfig {
-    /** Use a custom embed */
-    embed?: (embed: BetterEmbed, error: Error, guild: Guild | null | undefined) => BetterEmbed;
-    /** @defaultValue config.staff.mainServer.inviteUrl */
-    inviteUrl?: string;
-    /** The support server invite button label @defaultValue "Support Server" */
-    inviteButtonLabel?: string;
-    /** The error details button label @defaultValue "Details" */
-    detailButtonLabel?: string;
-    /** @defaultValue 30_000 // 30 seconds */
-    detailButtonIdleTimeout?: number;
-    /** Should the message be ephemeral? */
-    ephemeral?: boolean;
-    /** Should the message be deleted after a certain amount of time? */
-    deleteAfter?: number;
+declare enum SendMethod {
+    Reply = 0,
+    EditReply = 1,
+    FollowUp = 2,
+    Channel = 3,
+    MessageReply = 4,
+    MessageEdit = 5,
+    User = 6
+}
+type SendHandler = CommandInteraction | RepliableInteraction | TextBasedChannel | Message | GuildMember | User;
+type InteractionBasedSendHandler = CommandInteraction | RepliableInteraction;
+type EmbedResolvable = EmbedBuilder | BetterEmbed;
+type InteractionResolveable = CommandInteraction | RepliableInteraction;
+type UserResolvable = GuildMember | User | string;
+type SendableTextChannel = DMChannel | TextChannel | NewsChannel | ThreadChannel;
+
+interface ModuleImportOptions {
+    /** The directories to import from. */
+    dir: string | string[];
+    /** Recursively imports modules from subdirectories.
+     * @defaultValue true
+     **/
+    recursive?: boolean;
+    /** Only import modules that end with these suffixes.
+     *
+     * If set to `null` all files in the directory will be imported, which may lead to import errors if you have modules not related to commands in the same directory.
+     *
+     * Respectively, the default suffixes are `.slash`, `.ctx`, `.prefix`, and `.event`.
+     *
+     * @example
+     * // Example module filenames using the default suffixes
+     * "ping.slash.ts"
+     * "avatar.ctx.ts"
+     * "help.prefix.ts"
+     * "ready.event.ts"
+     */
+    suffix?: string | string[] | null;
+}
+interface AppModuleImports {
+    /** Default suffix: slash
+     * @example
+     * // Example module filename
+     * "ping.slash.ts"
+     */
+    slashCommands?: string | string[] | ModuleImportOptions;
+    /** Default suffix: ctx
+     * @example
+     * // Example module filename
+     * "avatar.ctx.ts"
+     */
+    contextCommands?: string | string[] | ModuleImportOptions;
+    /** Default suffix: prefix
+     * @example
+     * // Example module filename
+     * "help.prefix.ts"
+     */
+    prefixCommands?: string | string[] | ModuleImportOptions;
+    /** Default suffix: event
+     * @example
+     * // Example module filename
+     * "ready.event.ts"
+     */
+    events?: string | string[] | ModuleImportOptions;
 }
 interface VimcordFeatures {
-    /** Use global process error handlers @defaultValue `false` */
+    /** Use global process error handlers.
+     * @defaultValue true */
     useGlobalErrorHandlers?: boolean;
-    /** Use our default prefix command handler @defaultValue `true` */
+    /** Use our default prefix command handler.
+     * @defaultValue true */
     useDefaultPrefixCommandHandler?: boolean;
-    /** Use our default slash command handler @defaultValue `true` */
+    /** Use our default slash command handler.
+     * @defaultValue true */
     useDefaultSlashCommandHandler?: boolean;
-    /** Use our default context command handler @defaultValue `true` */
+    /** Use our default context command handler.
+     * @defaultValue true */
     useDefaultContextCommandHandler?: boolean;
     /** Reply to the user with an Uh-oh! embed when a command fails. If not using our default command handlers, you will have to implement this yourself using {@link sendCommandErrorEmbed}
      * @example
@@ -920,29 +1213,57 @@ interface VimcordFeatures {
      * }
      * ``` */
     enableCommandErrorMessage?: boolean | CommandErrorMessageConfig;
-    /** Update the state of {@link globalVimcordToolsConfig.devMode} whenever {@link VimcordAppConfig.devMode} is updated in the client. This is mainly useful for {@link BetterEmbed} to switch between devMode and production colors during runtime without having to update the global config manually @defaultValue `false` */
-    hookToolsDevMode?: boolean;
-    /** Setup and configure `dotenv` @defaultValue `false` */
-    useEnv?: boolean | DotenvConfigOptions;
     /** The maximum number of attempts to log into Discord @defaultValue `3` */
-    loginAttempts?: number;
-    /** Import modules from directories */
-    importModules?: {
-        events?: string | string[];
-        slashCommands?: string | string[];
-        prefixCommands?: string | string[];
-        contextCommands?: string | string[];
-    };
+    maxLoginAttempts?: number;
+    /** Automatically imports modules from these directories. */
+    importModules?: AppModuleImports;
 }
 interface VimcordConfig {
-    app: VimcordAppConfig;
-    staff: VimcordStaffConfig;
-    slashCommands: VimcordSlashCommandConfig;
-    prefixCommands: VimcordPrefixCommandConfig;
-    contextCommands: VimcordContextCommandConfig;
+    app: AppConfig;
+    staff: StaffConfig;
+    slashCommands: SlashCommandConfig;
+    prefixCommands: PrefixCommandConfig;
+    contextCommands: ContextCommandConfig;
+}
+interface VimcordCreateConfig {
+    options: ClientOptions;
+    features?: VimcordFeatures;
+    config?: PartialDeep<VimcordConfig>;
+}
+interface CommandErrorMessageConfig {
+    /** Use a custom embed */
+    embed?: (embed: EmbedResolvable, error: Error, guild: Guild | null | undefined) => EmbedResolvable;
+    /** @defaultValue config.staff.mainServer.inviteUrl */
+    inviteUrl?: string;
+    /** The support server invite button label @defaultValue "Support Server" */
+    inviteButtonLabel?: string;
+    /** The error details button label @defaultValue "Details" */
+    detailButtonLabel?: string;
+    /** @defaultValue 30_000 // 30 seconds */
+    detailButtonIdleTimeout?: number;
+    /** Should the message be ephemeral? */
+    ephemeral?: boolean;
+    /** Should the message be deleted after a certain amount of time? */
+    deleteAfter?: number;
 }
+
 declare class Vimcord<Ready extends boolean = boolean> extends Client<Ready> {
     static instances: Map<number, Vimcord<boolean>>;
+    private static emitter;
+    private clientStartingPromise;
+    static create(options: ClientOptions, features?: VimcordFeatures, config?: PartialDeep<VimcordConfig>): Vimcord;
+    static create(config: VimcordCreateConfig): Vimcord;
+    /**
+     * Returns an instance of Vimcord.
+     * @param clientId [default: 0]
+     */
+    static getInstance(clientId?: number): Vimcord | undefined;
+    /**
+     * Waits for a Vimcord instance to be ready.
+     * @param clientId [default: 0]
+     * @param timeoutMs [default: 60000]
+     */
+    static getReadyInstance(clientId?: number, timeoutMs?: number): Promise<Vimcord<true>>;
     readonly uuid: string;
     readonly clientId: number;
     readonly clientOptions: ClientOptions;
@@ -952,15 +1273,27 @@ declare class Vimcord<Ready extends boolean = boolean> extends Client<Ready> {
     readonly events: EventManager;
     readonly commands: CommandManager;
     db?: DatabaseManager;
-    logger: Logger & {
+    readonly logger: Logger & {
         clientBanner(client: Vimcord): void;
         clientReady(clientTag: string, guildCount: number): void;
         moduleLoaded(moduleName: string, count?: number, ignoredCount?: number): void;
         commandExecuted(commandName: string, username: string, guildName?: string): void;
         database(action: string, details?: string): void;
     };
-    private clientStartingPromise;
+    readonly error: ErrorHandler;
     constructor(options: ClientOptions, features?: VimcordFeatures, config?: PartialDeep<VimcordConfig>);
+    /** Current app name */
+    get $name(): string;
+    set $name(name: string);
+    /** Current app version */
+    get $version(): string;
+    set $version(version: string);
+    /** Current dev mode state */
+    get $devMode(): boolean;
+    set $devMode(mode: boolean);
+    /** Current verbose mode state */
+    get $verboseMode(): boolean;
+    set $verboseMode(mode: boolean);
     /** Returns the options, features, and config of this client. */
     toJSON(): {
         options: ClientOptions;
@@ -968,93 +1301,90 @@ declare class Vimcord<Ready extends boolean = boolean> extends Client<Ready> {
         config: VimcordConfig;
     };
     /** Makes a clone of this client. */
-    clone(): Vimcord<boolean>;
-    configureApp(options?: PartialDeep<VimcordAppConfig>): this;
-    configureStaff(options?: PartialDeep<VimcordStaffConfig>): this;
-    configureSlashCommands(options?: PartialDeep<VimcordSlashCommandConfig>): this;
-    configurePrefixCommands(options?: PartialDeep<VimcordPrefixCommandConfig>): this;
-    configureContextCommands(options?: PartialDeep<VimcordContextCommandConfig>): this;
-    importEventModules(dir: string | string[], replaceAll?: boolean): Promise<this>;
-    importSlashCommandModules(dir: string | string[], replaceAll?: boolean): Promise<this>;
-    importPrefixCommandModules(dir: string | string[], replaceAll?: boolean): Promise<this>;
-    importContextCommandModules(dir: string | string[], replaceAll?: boolean): Promise<this>;
-    useDatabase(db: DatabaseManager): Promise<boolean>;
-    waitForReady(): Promise<Vimcord<true>>;
+    clone(): Vimcord;
+    /**
+     * Modifies a client config.
+     * @param type The type of config to modify.
+     * @param options The options to set for the config.
+     */
+    configure<T extends keyof VimcordConfig>(type: T, options?: PartialDeep<VimcordConfig[T]>): this;
+    /** Builds the client by importing modules and registering builtin handlers. */
     build(): Promise<this>;
-    /** Automatically uses `process.env.TOKEN` or `process.env.TOKEN_DEV` if token isn't provided */
+    /**
+     * Imports modules into the client.
+     * @param type The type of modules to import.
+     * @param options The options to import the module with.
+     * @param set Replaces already imported modules with the ones found.
+     */
+    importModules<T extends keyof AppModuleImports>(type: T, options: AppModuleImports[T], set?: boolean): Promise<this>;
+    /**
+     * Allows Vimcord to handle environment variables using [dotenv](https://www.npmjs.com/package/dotenv).
+     * @param options Options for dotenv
+     * @see https://www.npmjs.com/package/dotenv
+     */
+    useEnv(options?: DotenvConfigOptions): this;
+    /**
+     * Connects to a database.
+     * @param db The database manager to use.
+     */
+    useDatabase(db: DatabaseManager): Promise<boolean>;
+    /**
+     * Fetches a user from the client, checking the cache first.
+     * @param userId The ID of the user to fetch.
+     */
+    fetchUser(userId: string | undefined | null): Promise<discord_js.User | null>;
+    /**
+     * Fetches a guild from the client, checking the cache first.
+     * @param guildId The ID of the guild to fetch.
+     */
+    fetchGuild(guildId: string | undefined | null): Promise<discord_js.Guild | null>;
+    /**
+     * Starts the client and connects to Discord.
+     * Automatically uses `process.env.TOKEN` or `process.env.TOKEN_DEV` if token isn't provided.
+     * @param token The Discord bot token.
+     * @param callback Runs after logging in.
+     */
     start(token?: string): Promise<string | null>;
-    start(preHook?: (client: Vimcord) => any): Promise<string | null>;
-    start(token?: string, preHook?: (client: Vimcord) => any): Promise<string | null>;
+    start(callback?: (client: Vimcord) => unknown): Promise<string | null>;
+    start(token?: string, callback?: (client: Vimcord) => unknown): Promise<string | null>;
+    /** Destroys the client and disconnects from Discord. */
     kill(): Promise<void>;
-    /** Shortcut for {@link fetchUser tools.fetchUser} */
-    fetchUser(id: string | undefined | null): Promise<User | null>;
-    /** Shortcut for {@link fetchGuild tools.fetchGuild} */
-    fetchGuild(id: string | undefined | null): Promise<Guild | null>;
 }
 
-declare enum CommandType {
-    Slash = 0,
-    Prefix = 1,
-    Context = 2
-}
-declare enum MissingPermissionReason {
-    User = 0,
-    Bot = 1,
-    Role = 2,
-    UserBlacklisted = 3,
-    RoleBlacklisted = 4,
-    NotInGuild = 5,
-    NotGuildOwner = 6,
-    NotBotOwner = 7,
-    NotBotStaff = 8
-}
-declare enum RateLimitScope {
-    User = 0,
-    Guild = 1,
-    Channel = 2,
-    Global = 3
-}
-type BaseCommandParameters<T extends CommandType> = T extends CommandType.Slash ? [client: Vimcord<true>, interaction: ChatInputCommandInteraction] : T extends CommandType.Prefix ? [client: Vimcord<true>, message: Message] : T extends CommandType.Context ? [client: Vimcord<true>, interaction: ContextMenuCommandInteraction] : never;
-interface BaseCommandConfig<T extends CommandType> {
-    /** Is this command enabled? @defaultValue true */
-    enabled?: boolean;
-    /** Custom conditions that must be met for this command to execute */
-    conditions?: Array<(...args: BaseCommandParameters<T>) => boolean | Promise<boolean>>;
-    /** Command permission requirements */
-    permissions?: CommandPermissions;
-    /** Command metadata configuration */
-    metadata?: CommandMetadata;
-    /** Rate limiting options */
-    rateLimit?: CommandRateLimitOptions<(...args: BaseCommandParameters<T>) => any>;
-    /** Log whenever a command is executed? @defaultValue true */
-    logExecution?: boolean;
-    /** Executed before the main command logic */
-    beforeExecute?: (...args: BaseCommandParameters<T>) => any;
-    /** The main command function that will be executed */
-    execute?: (...args: BaseCommandParameters<T>) => any;
-    /** Executed after successful execution */
-    afterExecute?: (result: any, ...args: BaseCommandParameters<T>) => any;
-    /** Executed when the required permissions are not met */
-    onMissingPermissions?: (results: CommandPermissionResults, ...args: BaseCommandParameters<T>) => any;
-    /** Executed when the required conditions are not met */
-    onConditionsNotMet?: (...args: BaseCommandParameters<T>) => any;
-    /** Executed when this command is used when its disabled */
-    onUsedWhenDisabled?: (...args: BaseCommandParameters<T>) => any;
-    /** Executed when the rate limit is hit */
-    onRateLimit?: (...args: BaseCommandParameters<T>) => any;
-    /** Custom error handler */
-    onError?: (error: Error, ...args: BaseCommandParameters<T>) => any;
-}
-interface BaseAppCommandConfig {
-    /** Command deployment configuration */
-    deployment?: AppCommandDeployment;
-}
-interface CommandInternalRateLimitData {
-    /** Number of times executed */
-    executions: number;
-    /** Timestamp of latest execution */
-    timestamp: number;
-}
+declare const clientLoggerFactory: (client: Vimcord) => Logger & {
+    clientBanner(client: Vimcord): void;
+    clientReady(clientTag: string, guildCount: number): void;
+    moduleLoaded(moduleName: string, count?: number, ignoredCount?: number): void;
+    commandExecuted(commandName: string, username: string, guildName?: string): void;
+    database(action: string, details?: string): void;
+};
+
+declare const DEFAULT_MODULE_SUFFIXES: {
+    readonly slashCommands: ".slash";
+    readonly contextCommands: ".ctx";
+    readonly prefixCommands: ".prefix";
+    readonly events: ".event";
+};
+declare const configSetters: Record<keyof VimcordConfig, (options: PartialDeep<VimcordConfig[keyof VimcordConfig]>, existing?: VimcordConfig[keyof VimcordConfig]) => VimcordConfig[keyof VimcordConfig]>;
+declare const moduleImporters: Record<keyof AppModuleImports, (client: Vimcord, options: AppModuleImports[keyof AppModuleImports], set?: boolean) => any>;
+declare function defineClientOptions(options: ClientOptions): ClientOptions;
+declare function defineVimcordFeatures(features: VimcordFeatures): VimcordFeatures;
+declare function defineVimcordConfig(config: PartialDeep<VimcordConfig>): VimcordConfig;
+/**
+ * Returns an instance of Vimcord.
+ * @param clientId [default: 0]
+ */
+declare const useClient: typeof Vimcord.getInstance;
+/**
+ * Waits for a Vimcord instance to be ready.
+ * @param clientId [default: 0]
+ * @param timeoutMs [default: 60000]
+ */
+declare const useReadyClient: typeof Vimcord.getReadyInstance;
+/**
+ * Creates a new instance of Vimcord.
+ */
+declare const createClient: typeof Vimcord.create;
 
 declare abstract class BaseCommandBuilder<T extends CommandType, O extends BaseCommandConfig<T> = BaseCommandConfig<T>> {
     readonly uuid: string;
@@ -1148,12 +1478,6 @@ declare abstract class BaseCommandBuilder<T extends CommandType, O extends BaseC
     setOnError(callback: (error: Error, ...args: BaseCommandParameters<T>) => any): this;
 }
 
-declare const BUILTIN_ContextCommandHandler: EventBuilder<"interactionCreate">;
-
-declare const BUILTIN_PrefixCommandHandler: EventBuilder<"messageCreate">;
-
-declare const BUILTIN_SlashCommandHandler: EventBuilder<"interactionCreate">;
-
 type MongoPlugin<Definition extends object> = (builder: MongoSchemaBuilder<Definition>) => void;
 type ExtractReturn<T> = T extends (this: any, ...args: any) => infer R ? Awaited<R> : never;
 type LeanOrHydratedDocument<T, O extends QueryOptions<T>> = O["lean"] extends false ? HydratedDocument<T> : Require_id<T>;
@@ -1249,12 +1573,12 @@ declare class MongoSchemaBuilder<Definition extends object = any> {
     createHexId(bytes: number, path: keyof Require_id<Definition>, maxRetries?: number): Promise<string>;
     count(filter?: RootFilterQuery<Definition>, options?: mongo.CountOptions & MongooseBaseQueryOptions<Definition> & mongo.Abortable): Promise<number>;
     exists(filter: RootFilterQuery<Definition>): Promise<boolean>;
-    create(query: Partial<Require_id<Definition>>[], options?: CreateOptions): Promise<(mongoose.Document<unknown, {}, Definition, {}, {}> & (Require_id<Definition> extends infer T ? T extends Require_id<Definition> ? T extends {
+    create(query: Partial<Require_id<Definition>>[], options?: CreateOptions): Promise<(Document<unknown, {}, Definition, {}, {}> & (Require_id<Definition> extends infer T ? T extends Require_id<Definition> ? T extends {
         __v?: infer U;
     } ? T : T & {
         __v: number;
     } : never : never))[]>;
-    upsert(filter: RootFilterQuery<Definition>, query: Partial<Require_id<Definition>>, options?: QueryOptions<Definition>): Promise<mongoose.Document<unknown, {}, Definition, {}, {}> & (Require_id<Definition> extends infer T ? T extends Require_id<Definition> ? T extends {
+    upsert(filter: RootFilterQuery<Definition>, query: Partial<Require_id<Definition>>, options?: QueryOptions<Definition>): Promise<Document<unknown, {}, Definition, {}, {}> & (Require_id<Definition> extends infer T ? T extends Require_id<Definition> ? T extends {
         __v?: infer U;
     } ? T : T & {
         __v: number;
@@ -1267,8 +1591,23 @@ declare class MongoSchemaBuilder<Definition extends object = any> {
     update<Options extends QueryOptions<Definition>>(filter: RootFilterQuery<Definition>, update: UpdateQuery<Definition>, options?: Options): Promise<LeanOrHydratedDocument<Definition, Options> | null | undefined>;
     updateAll(filter: RootFilterQuery<Definition>, update: UpdateQuery<Definition>, options?: mongo.UpdateOptions & MongooseUpdateQueryOptions<Definition>): Promise<mongoose.UpdateWriteOpResult>;
     aggregate<T extends any>(pipeline: PipelineStage[], options?: AggregateOptions): Promise<T[]>;
+    bulkWrite(ops: AnyBulkWriteOperation[], options?: MongooseBulkWriteOptions): Promise<mongo.BulkWriteResult>;
+    bulkSave(docs: Document[], options?: MongooseBulkWriteOptions): Promise<mongo.BulkWriteResult & {
+        mongoose?: {
+            validationErrors: mongoose.Error[];
+            results: Array<mongoose.Error | mongo.WriteError | null>;
+        };
+    }>;
 }
 
+declare const contextCommandHandler: EventBuilder<"interactionCreate">;
+
+declare const prefixCommandHandler: EventBuilder<"messageCreate">;
+
+declare const slashCommandHandler: EventBuilder<"interactionCreate">;
+
+declare function validateCommandPermissions(permissions: CommandPermissions, client: Vimcord<true>, user: GuildMember | User, command: CommandInteraction | string): CommandPermissionResults;
+
 interface BetterCollectorOptions<T extends MessageComponentType> {
     type?: T;
     participants?: UserResolvable$1[];
@@ -1282,7 +1621,7 @@ interface BetterCollectorOptions<T extends MessageComponentType> {
     maxComponents?: number;
     maxUsers?: number;
     onTimeout?: CollectorTimeoutType;
-    config?: VimcordToolsConfig;
+    config?: PartialDeep<ToolsConfig>;
 }
 interface ListenerOptions<ComponentType extends MessageComponentType = MessageComponentType, InGuild extends boolean = boolean> {
     participants?: UserResolvable$1[];
@@ -1361,7 +1700,7 @@ interface BetterModalOptions {
     /** Max 5 components. */
     components?: BetterModalComponent[];
     /** A custom Vimcord config. */
-    config?: VimcordToolsConfig;
+    config?: ToolsConfig;
 }
 interface AwaitSubmitOptions extends Omit<AwaitModalSubmitOptions<ModalSubmitInteraction>, "filter" | "time"> {
     /** The time to wait for the modal to be submitted in milliseconds. */
@@ -1381,6 +1720,8 @@ interface ModalSubmitResult<T extends any = any> {
     reply: (options: RequiredDynaSendOptions) => Promise<Message | null>;
     /** Defers the interaction, closing the modal. */
     deferUpdate: (options?: InteractionDeferUpdateOptions) => Promise<InteractionResponse>;
+    /** Follow up the interaction. */
+    followUp: (options: string | MessagePayload | InteractionReplyOptions) => Promise<Message | null>;
 }
 declare class BetterModal {
     readonly id: string;
@@ -1460,7 +1801,7 @@ interface PaginatorOptions {
     dynamic?: boolean;
     timeout?: number;
     onTimeout?: PaginationTimeoutType;
-    config?: VimcordToolsConfig;
+    config?: PartialDeep<ToolsConfig>;
 }
 interface PaginatorData {
     message: Message | null;
@@ -1489,7 +1830,7 @@ interface PaginatorData {
     };
     components: {
         chapterSelect: StringSelectMenuBuilder;
-        navigation: Record<keyof VimcordToolsConfig["paginator"]["buttons"], ButtonBuilder>;
+        navigation: Record<keyof ToolsConfig["paginator"]["buttons"], ButtonBuilder>;
         actionRows: {
             chapterSelect: ActionRowBuilder<StringSelectMenuBuilder>;
             navigation: ActionRowBuilder<ButtonBuilder>;
@@ -1571,7 +1912,7 @@ interface PromptOptions {
     /** @defaultValue [PromptResolveType.DeleteOnConfirm, PromptResolveType.DeleteOnReject] */
     onResolve?: PromptResolveType[];
     timeout?: number;
-    config?: VimcordToolsConfig;
+    config?: PartialDeep<ToolsConfig>;
 }
 interface PromptResult {
     message: Message | null;
@@ -1596,7 +1937,7 @@ declare class Prompt {
     }>;
     readonly onResolve: PromptResolveType[];
     readonly timeout: number;
-    readonly config: VimcordToolsConfig;
+    readonly config: ToolsConfig;
     private message;
     constructor(options?: PromptOptions);
     private createDefaultForm;
@@ -1642,7 +1983,7 @@ declare function cleanMention(str: string | undefined): string | undefined;
  * @param content - The message's clean content to parse. Will be used if message.mentions isn't populated.
  * @param type - The type of mention.
  * @param index - The argument index in the content. Default is `0`
- * @param idOnly - Whether to return the ID instead of the fecthed object. */
+ * @param idOnly - Whether to return the ID instead of the fetched object. */
 declare function getMessageMention<M extends Message, T extends MentionType>(message: M, content: string | undefined | null, type: T, index: number, idOnly: true): Promise<string | null>;
 declare function getMessageMention<M extends Message, T extends MentionType>(message: M, content: string | undefined | null, type: T, index?: number, idOnly?: false): Promise<FetchedMessageMention<T, M extends Message<true> ? true : false> | null>;
 /** Get the ID of the first mention of a specified type from a message or message content.
@@ -1671,19 +2012,37 @@ declare function fetchMember(guild: Guild, memberId: string | undefined | null):
  * @param channelId - The ID of the channel to fetch.
  * @param type - The type of channel to fetch. */
 declare function fetchChannel<T extends ChannelType>(guild: Guild, channelId: string | undefined | null, type?: T): Promise<FetchedChannel<T> | null>;
-/** Fetch a role from a guild, checking the cache first.
- * @param guild - The guild to fetch the role from.
- * @param roleId - The ID of the role to fetch. */
-declare function fetchRole(guild: Guild, roleId: string | undefined | null): Promise<Role | null>;
 /** Fetch a message from a channel, checking the cache first.
  * @param channel - The channel to fetch the message from.
  * @param messageId - The ID of the message to fetch. */
 declare function fetchMessage(channel: GuildTextBasedChannel | VoiceBasedChannel, messageId: string | undefined | null): Promise<Message | null>;
+/** Fetch a role from a guild, checking the cache first.
+ * @param guild - The guild to fetch the role from.
+ * @param roleId - The ID of the role to fetch. */
+declare function fetchRole(guild: Guild, roleId: string | undefined | null): Promise<Role | null>;
+
+declare function sendCommandErrorEmbed(client: Vimcord, error: Error, guild: Guild | null | undefined, messageOrInteraction: Message | CommandInteraction): Promise<Message<boolean> | null>;
+
+declare function createConfigFactory<T>(defaultConfig: T, validate?: (config: T) => void): (options?: PartialDeep<T>, existing?: T) => T;
+
+declare function getProcessDir(): string;
+declare function importModulesFromDir<T extends any>(dir: string, suffix?: string): Promise<{
+    module: T;
+    path: string;
+}[]>;
 
+/** Reads the `package.json` file from the current working directory. */
+declare function getPackageJson(): any;
+/** Checks if the process was ran using the `--dev` flag. */
+declare function getDevMode(): boolean;
+
+type VimcordCLIMode = "on" | "off";
 interface VimcordCLIOptions {
     prefix: string;
 }
 declare class VimcordCLI {
+    static mode: VimcordCLIMode;
+    static setMode(mode: VimcordCLIMode): void;
     rl: Interface;
     options: VimcordCLIOptions;
     commands: Map<string, {
@@ -1697,24 +2056,6 @@ declare class VimcordCLI {
     addCommand(commandName: string, description: string, fn: (args: string[], content: string) => void): void;
     removeCommand(commandName: string): boolean;
 }
-declare const CLI: VimcordCLI;
-/** One-time function to be called during client creation */
-declare function initCLI(): void;
-
-type VimcordConfigOptions = PartialDeep<VimcordConfig>;
-declare function useClient(clientId?: number): Vimcord<boolean> | undefined;
-declare function useReadyClient(clientId?: number): Promise<Vimcord<true> | undefined>;
-declare function createClient(options: ClientOptions, features?: VimcordFeatures, config?: VimcordConfigOptions): Vimcord<boolean>;
-
-declare function getCallerFileName(): string | undefined;
-declare function getProcessDir(): string;
-declare function importModulesFromDir<T extends any>(dir: string, suffix?: string): Promise<{
-    module: T;
-    path: string;
-}[]>;
-
-declare function sendCommandErrorEmbed(client: Vimcord, error: Error, guild: Guild | null | undefined, messageOrInteraction: Message | CommandInteraction): Promise<Message<boolean> | null>;
-
-declare function validateCommandPermissions(permissions: CommandPermissions, client: Vimcord<true>, user: GuildMember | User, command: CommandInteraction | string): CommandPermissionResults;
+declare let CLI: VimcordCLI;
 
-export { type AnySlashCommandBuilder, type AppCommandDeployment, type AwaitSubmitOptions, BUILTIN_ContextCommandHandler, BUILTIN_PrefixCommandHandler, BUILTIN_SlashCommandHandler, type BaseAppCommandConfig, BaseCommandBuilder, type BaseCommandConfig, BaseCommandManager, type BaseCommandParameters, type BetterChannelSelectComponent, BetterCollector, type BetterCollectorOptions, BetterContainer, type BetterContainerData, BetterEmbed, type BetterEmbedAuthor, type BetterEmbedContext, type BetterEmbedData, type BetterEmbedFooter, type BetterEmbedTitle, type BetterFileUploadSelectComponent, type BetterMentionableSelectComponent, BetterModal, type BetterModalComponent, type BetterModalOptions, type BetterRoleSelectComponent, type BetterStringSelectComponent, type BetterTextInputComponent, type BetterUserSelectComponent, type ButtonHandler, CLI, type Chapter, type ChapterData, type ClientActivity, type ClientStatus, CollectorTimeoutType, type CommandByCategory, type CommandErrorMessageConfig, type CommandFilter, type CommandInternalRateLimitData, CommandManager, type CommandMetadata, type CommandPermissionResults, type CommandPermissions, type CommandRateLimitOptions, CommandType, ContextCommandBuilder, type ContextCommandConfig, ContextCommandManager, type CustomButton, type DatabaseManager, DynaSend, type DynaSendOptions, type EmbedResolvable, EventBuilder, type EventConfig, type EventDeployment, EventManager, type EventMetadata, type EventParameters, type EventRateLimitOptions, type ExtractReturn, type FetchedChannel, type FetchedMessageMention, type GetMessageMentionOptions, type InteractionBasedSendHandler, type InteractionResolveable, LOGGER_COLORS, type LeanOrHydratedDocument, type ListenerOptions, LogLevel, Logger, type LoggerOptions, type MentionType, MissingPermissionReason, type ModalSubmitResult, MongoDatabase, type MongoPlugin, MongoSchemaBuilder, type MongoSchemaOptions, type PageIndex, type PageResolvable, type PaginationEvent, PaginationTimeoutType, PaginationType, Paginator, type PaginatorData, type PaginatorOptions, PrefixCommandBuilder, type PrefixCommandConfig, PrefixCommandManager, Prompt, type PromptOptions, PromptResolveType, type PromptResult, RateLimitScope, type RequiredDynaSendOptions, type SendHandler, SendMethod, type SendableComponent, type SendableTextChannel, type SinglePageResolvable, SlashCommandBuilder, type SlashCommandConfig, SlashCommandManager, StatusManager, StatusType, type UserResolvable, Vimcord, type VimcordAppConfig, VimcordCLI, type VimcordCLIOptions, type VimcordClientStatus, type VimcordCommandBuilderByType, type VimcordConfig, type VimcordConfigOptions, type VimcordContextCommandConfig, type VimcordFeatures, type VimcordPrefixCommandConfig, type VimcordSlashCommandConfig, type VimcordStaffConfig, type VimcordToolsConfig, __zero, cleanMention, createClient, createMongoPlugin, createMongoSchema, createToolsConfig, createVimcordAppConfig, createVimcordContextCommandConfig, createVimcordPrefixCommandConfig, createVimcordSlashCommandConfig, createVimcordStaffConfig, createVimcordStatusConfig, defineGlobalToolsConfig, dynaSend, fetchChannel, fetchGuild, fetchMember, fetchMessage, fetchRole, fetchUser, getCallerFileName, getFirstMentionId, getMessageMention, getProcessDir, globalVimcordToolsConfig, importModulesFromDir, initCLI, isMentionOrSnowflake, logger, prompt, sendCommandErrorEmbed, useClient, useReadyClient, validateCommandPermissions };
+export { type AnySlashCommandBuilder, type AppCommandDeployment, type AppConfig, type AppModuleImports, type AwaitSubmitOptions, type BaseAppCommandConfig, BaseCommandBuilder, type BaseCommandConfig, BaseCommandManager, type BaseCommandParameters, type BetterChannelSelectComponent, BetterCollector, type BetterCollectorOptions, BetterContainer, type BetterContainerData, BetterEmbed, type BetterEmbedAuthor, type BetterEmbedContext, type BetterEmbedData, type BetterEmbedFooter, type BetterEmbedTitle, type BetterFileUploadSelectComponent, type BetterMentionableSelectComponent, BetterModal, type BetterModalComponent, type BetterModalOptions, type BetterRoleSelectComponent, type BetterStringSelectComponent, type BetterTextInputComponent, type BetterUserSelectComponent, type ButtonHandler, CLI, type Chapter, type ChapterData, type ClientActivity, type ClientStatus, CollectorTimeoutType, type CommandByCategory, type CommandErrorMessageConfig, type CommandFilter, type CommandInternalRateLimitData, CommandManager, type CommandMetadata, type CommandPermissionResults, type CommandPermissions, type CommandRateLimitOptions, CommandType, ContextCommandBuilder, type ContextCommandConfig, ContextCommandManager, type CustomButton, DEFAULT_MODULE_SUFFIXES, type DatabaseManager, DynaSend, type DynaSendOptions, type EmbedResolvable, ErrorHandler, EventBuilder, type EventConfig, type EventDeployment, EventManager, type EventMetadata, type EventParameters, type EventRateLimitOptions, type ExtractReturn, type FetchedChannel, type FetchedMessageMention, type GetMessageMentionOptions, type InteractionBasedSendHandler, type InteractionResolveable, LOGGER_COLORS, type LeanOrHydratedDocument, type ListenerOptions, LogLevel, Logger, type LoggerOptions, type MentionType, MissingPermissionReason, type ModalSubmitResult, type ModuleImportOptions, ModuleImporter, MongoDatabase, type MongoPlugin, MongoSchemaBuilder, type MongoSchemaOptions, type PageIndex, type PageResolvable, type PaginationEvent, PaginationTimeoutType, PaginationType, Paginator, type PaginatorData, type PaginatorOptions, PrefixCommandBuilder, type PrefixCommandConfig, PrefixCommandManager, Prompt, type PromptOptions, PromptResolveType, type PromptResult, RateLimitScope, type RequiredDynaSendOptions, type SendHandler, SendMethod, type SendableComponent, type SendableTextChannel, type SinglePageResolvable, SlashCommandBuilder, type SlashCommandConfig, SlashCommandManager, type StaffConfig, StatusManager, StatusType, type ToolsConfig, type UserResolvable, Vimcord, VimcordCLI, type VimcordCLIMode, type VimcordCLIOptions, type VimcordClientStatus, type VimcordCommandBuilderByType, type VimcordConfig, type VimcordCreateConfig, type VimcordFeatures, __zero, cleanMention, clientLoggerFactory, configSetters, contextCommandHandler, createAppConfig, createClient, createConfigFactory, createContextCommandConfig, createMongoPlugin, createMongoSchema, createPrefixCommandConfig, createSlashCommandConfig, createStaffConfig, createToolsConfig, createVimcordStatusConfig, defineClientOptions, defineGlobalToolsConfig, defineVimcordConfig, defineVimcordFeatures, dynaSend, fetchChannel, fetchGuild, fetchMember, fetchMessage, fetchRole, fetchUser, getDevMode, getFirstMentionId, getMessageMention, getPackageJson, getProcessDir, globalToolsConfig, importModulesFromDir, isMentionOrSnowflake, logger, moduleImporters, prefixCommandHandler, prompt, sendCommandErrorEmbed, slashCommandHandler, useClient, useReadyClient, validateCommandPermissions };