vimcord 1.0.0 → 1.0.2

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import * as discord_js from 'discord.js';
-import { PermissionResolvable, SlashCommandBuilder as SlashCommandBuilder$1, SlashCommandOptionsOnlyBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandsOnlyBuilder, SlashCommandSubcommandGroupBuilder, ActivityType, ContextMenuCommandBuilder, ContextMenuCommandInteraction, Message, ChatInputCommandInteraction, REST, ClientEvents, CommandInteraction, RepliableInteraction, TextBasedChannel, 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, APITextInputComponent, APIStringSelectComponent, APIChannelSelectComponent, APIUserSelectComponent, APIRoleSelectComponent, APIMentionableSelectComponent, APIFileUploadComponent, ModalSubmitInteraction, APIModalInteractionResponseCallbackData, ModalBuilder, Interaction, AwaitModalSubmitOptions, SelectMenuComponentOptionData, StringSelectMenuOptionBuilder, StringSelectMenuInteraction, ButtonInteraction, MessageReaction, UserResolvable as UserResolvable$1, StringSelectMenuBuilder, ButtonBuilder, InteractionCollector, ReactionCollector, APIButtonComponent, ChannelType, PartialGroupDMChannel, PartialDMChannel, GuildBasedChannel, AnyThreadChannel, VoiceBasedChannel, CategoryChannel, Channel, Role, GuildTextBasedChannel } from 'discord.js';
+import { SlashCommandBuilder as SlashCommandBuilder$1, SlashCommandOptionsOnlyBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandsOnlyBuilder, SlashCommandSubcommandGroupBuilder, PermissionResolvable, ActivityType, ContextMenuCommandBuilder, ChatInputCommandInteraction, REST, 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, ModalSubmitInteraction, APIModalInteractionResponseCallbackData, ModalBuilder, Interaction, AwaitModalSubmitOptions, 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 mongoose, { QueryOptions, HydratedDocument, Require_id, SchemaDefinition, Schema, Model, RootFilterQuery, ProjectionType, UpdateQuery, PipelineStage, AggregateOptions } from 'mongoose';
+import mongoose, { ClientSessionOptions, QueryOptions, HydratedDocument, Require_id, SchemaDefinition, Schema, Model, RootFilterQuery, mongo, MongooseBaseQueryOptions, CreateOptions, ProjectionType, UpdateQuery, MongooseUpdateQueryOptions, PipelineStage, AggregateOptions } from 'mongoose';
 import { PartialDeep } from 'type-fest';
-import { ScheduledTask } from 'node-cron';
 import EventEmitter from 'node:events';
+import { Loop } from 'qznt';
 import { Interface } from 'node:readline';
 
 type AnySlashCommandBuilder = SlashCommandBuilder$1 | SlashCommandOptionsOnlyBuilder | SlashCommandSubcommandBuilder | SlashCommandSubcommandsOnlyBuilder | SlashCommandSubcommandGroupBuilder;
@@ -76,7 +76,9 @@ interface MongoConnectionOptions {
     /** The maximum number of attempts to connect to MongoDB @defaultValue `3` */
     maxRetries?: number;
 }
-declare function useMongoDatabase(index?: number): Promise<MongoDatabase>;
+declare function useMongoDatabase(instanceIndex?: number): Promise<MongoDatabase>;
+declare function useReadyMongoDatabase(instanceIndex?: number): Promise<MongoDatabase>;
+declare function createMongoSession(instanceIndex?: number, options?: ClientSessionOptions): Promise<mongoose.mongo.ClientSession>;
 declare class MongoDatabase {
     client: Vimcord;
     readonly name: string;
@@ -140,6 +142,11 @@ interface VimcordPrefixCommandConfig extends BaseCommandConfig<CommandType.Prefi
     allowMentionAsPrefix: boolean;
     /** @default 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;
 
@@ -148,7 +155,7 @@ interface VimcordContextCommandConfig extends BaseCommandConfig<CommandType.Cont
 declare function createVimcordContextCommandConfig(options?: PartialDeep<VimcordContextCommandConfig>): VimcordContextCommandConfig;
 
 interface LoggerOptions {
-    colors?: Partial<typeof DEFAULT_COLORS>;
+    colors?: Partial<typeof LOGGER_COLORS>;
     prefix?: string | null;
     prefixEmoji?: string | null;
     minLevel?: LogLevel;
@@ -162,7 +169,7 @@ declare enum LogLevel {
     WARN = 3,
     ERROR = 4
 }
-declare const DEFAULT_COLORS: {
+declare const LOGGER_COLORS: {
     primary: string;
     success: string;
     warn: string;
@@ -196,7 +203,7 @@ declare class Logger {
     setPrefixEmoji(prefixEmoji: string | null): this;
     setMinLevel(minLevel: LogLevel): this;
     setShowTimestamp(show: boolean): this;
-    setColors(colors: Partial<typeof DEFAULT_COLORS>): 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;
@@ -242,9 +249,9 @@ type VimcordStatusManagerEvents = {
     changed: [ClientActivity];
     cleared: [];
     rotation: [ClientActivity];
-    rotationPaused: [ScheduledTask];
-    rotationStarted: [ScheduledTask];
-    rotationDestroyed: [];
+    paused: [Loop];
+    started: [Loop];
+    destroyed: [];
 };
 declare class VimcordStatusManager {
     client: Vimcord;
@@ -267,116 +274,121 @@ declare class VimcordStatusManager {
     clear(): Promise<this>;
 }
 
-interface ContextCommandConfig extends BaseCommandOptions<CommandType.Context>, BaseAppCommandConfig, BaseCommandFunctionConfig<CommandType.Context> {
-    /** Context menu command builder */
+interface ContextCommandConfig extends BaseCommandConfig<CommandType.Context>, BaseAppCommandConfig {
     builder: ContextMenuCommandBuilder | ((builder: ContextMenuCommandBuilder) => ContextMenuCommandBuilder);
-    /** Defer reply */
     deferReply?: boolean | {
         ephemeral?: boolean;
     };
 }
 declare class ContextCommandBuilder extends BaseCommandBuilder<CommandType.Context, ContextCommandConfig> {
     builder: ContextMenuCommandBuilder;
-    deferReply?: boolean | {
-        ephemeral?: boolean;
-    };
-    deployment?: AppCommandDeployment;
     constructor(config: ContextCommandConfig);
+    private handleExecution;
     private validateBuilder;
-    private validateConfig;
-    toConfig(): ContextCommandConfig;
-    setBuilder(builder: ContextMenuCommandBuilder | ((builder: ContextMenuCommandBuilder) => ContextMenuCommandBuilder)): this;
-    setDeferReply(defer: boolean | {
-        ephemeral?: boolean;
-    }): this;
+    setBuilder(builder: ContextCommandConfig["builder"]): this;
+    setDeferReply(defer: ContextCommandConfig["deferReply"]): this;
     setDeployment(deployment: AppCommandDeployment): this;
-    executeCommand(client: Vimcord<true>, interaction: ContextMenuCommandInteraction): Promise<any>;
+    setExecute(fn: ContextCommandConfig["execute"]): this;
+    toConfig(): ContextCommandConfig;
 }
 
-interface PrefixCommandConfig extends BaseCommandOptions<CommandType.Prefix>, BaseCommandFunctionConfig<CommandType.Prefix> {
+/**
+ * Configuration specific to Prefix-based commands
+ */
+interface PrefixCommandConfig extends BaseCommandConfig<CommandType.Prefix> {
+    /** The primary name of the command */
     name: string;
+    /** Alternative triggers for this command */
     aliases?: string[];
+    /** A brief explanation of what the command does */
     description?: string;
 }
 declare class PrefixCommandBuilder extends BaseCommandBuilder<CommandType.Prefix, PrefixCommandConfig> {
-    name: string;
-    aliases?: string[];
-    description?: string;
     constructor(config: PrefixCommandConfig);
-    private validateConfig;
+    /**
+     * Specialized execution logic for Prefix Commands.
+     */
+    private handleExecution;
+    private validatePrefixConfig;
+    /**
+     * Set the primary name of the command.
+     */
+    setName(name: string): this;
+    /**
+     * Set or replace the command aliases.
+     */
+    setAliases(aliases: string[]): this;
+    /**
+     * Add additional aliases without clearing existing ones.
+     */
+    addAliases(...aliases: string[]): this;
+    /**
+     * Set the command description.
+     */
+    setDescription(description: string): this;
+    /**
+     * Override setExecute to ensure handleExecution remains the entry point.
+     * This is the only base method we need to redefine.
+     */
+    setExecute(fn: PrefixCommandConfig["execute"]): this;
+    /**
+     * Converts the current builder state back into a config object.
+     */
     toConfig(): PrefixCommandConfig;
-    executeCommand(client: Vimcord<true>, message: Message): Promise<any>;
 }
 
-interface SlashCommandConfig extends BaseCommandOptions<CommandType.Slash>, BaseAppCommandConfig, BaseCommandFunctionConfig<CommandType.Slash> {
-    /** Slash command builder */
+interface SlashCommandConfig extends BaseCommandConfig<CommandType.Slash>, BaseAppCommandConfig {
     builder: AnySlashCommandBuilder | ((builder: SlashCommandBuilder$1) => AnySlashCommandBuilder);
-    /** Defer reply */
     deferReply?: boolean | {
         ephemeral?: boolean;
     };
-    /** Deployment options */
-    deployment?: AppCommandDeployment;
-    /** Map sub-command names to their own execute handler */
-    routes?: {
+    routes?: Array<{
         name: string;
         handler: (client: Vimcord<true>, interaction: ChatInputCommandInteraction) => any;
-    }[];
-    /** Executed when an unmapped sub-command route is used */
+    }>;
     onUnknownRouteHandler?: (client: Vimcord<true>, interaction: ChatInputCommandInteraction) => any;
 }
 declare class SlashCommandBuilder extends BaseCommandBuilder<CommandType.Slash, SlashCommandConfig> {
     builder: AnySlashCommandBuilder;
-    deferReply?: boolean | {
-        ephemeral?: boolean;
-    };
-    deployment?: AppCommandDeployment;
-    routes: Map<string, (...args: any) => any>;
-    onUnknownRouteHandler?: (...args: any) => any;
+    private readonly routes;
     constructor(config: SlashCommandConfig);
+    private handleExecution;
     private validateBuilder;
-    private validateConfig;
-    toConfig(): SlashCommandConfig;
-    setBuilder(builder: AnySlashCommandBuilder | ((builder: SlashCommandBuilder$1) => AnySlashCommandBuilder)): this;
-    setDeferReply(defer: boolean | {
-        ephemeral?: boolean;
-    }): this;
+    setBuilder(builder: SlashCommandConfig["builder"]): this;
+    setDeferReply(defer: SlashCommandConfig["deferReply"]): this;
     setDeployment(deployment: AppCommandDeployment): this;
-    setRoutes(...routes: {
-        name: string;
-        handler: (client: Vimcord<true>, interaction: ChatInputCommandInteraction) => any;
-    }[]): this;
-    addRoutes(...routes: {
-        name: string;
-        handler: (client: Vimcord<true>, interaction: ChatInputCommandInteraction) => any;
-    }[]): this;
-    setUnknownRouteHandler(handler: (client: Vimcord<true>, interaction: ChatInputCommandInteraction) => any): this;
-    executeCommand(client: Vimcord<true>, interaction: ChatInputCommandInteraction): Promise<any>;
+    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 class VimcordCommandManager {
-    slash: VimcordSlashCommandManager;
-    prefix: VimcordPrefixCommandManager;
-    context: VimcordContextCommandManager;
-    constructor(client: Vimcord);
-}
-declare class VimcordSlashCommandManager {
-    client: Vimcord;
-    commands: Map<string, VimcordCommandBuilderByType<CommandType.Slash>>;
-    rest: REST;
-    constructor(client: Vimcord);
-    get(name: string): SlashCommandBuilder | undefined;
+/**
+ * Shared logic for Application Commands (Slash & Context)
+ */
+declare abstract class VimcordAppCommandManager<T extends CommandType.Slash | CommandType.Context> {
+    protected client: Vimcord;
+    protected typeName: string;
+    commands: Map<string, VimcordCommandBuilderByType<T>>;
+    protected rest: REST;
+    constructor(client: Vimcord, typeName: string);
+    get(name: string): VimcordCommandBuilderByType<T> | undefined;
+    /**
+     * Filters and returns commands based on deployment options
+     */
     getAll(options?: {
         names?: string[];
         fuzzyNames?: string[];
-        guilds?: string[];
         globalOnly?: boolean;
         ignoreDeploymentOptions?: boolean;
-    }): Map<string, SlashCommandBuilder>;
-    /** Import command modules that end with `.slash` */
-    importFrom(dir: string | string[], replaceAll?: boolean): Promise<Map<string, SlashCommandBuilder>>;
+    }): Map<string, VimcordCommandBuilderByType<T>>;
+    registerGlobal(options?: {
+        commands?: string[];
+        fuzzyCommands?: string[];
+    }): Promise<void>;
     registerGuild(options?: {
         commands?: string[];
         fuzzyCommands?: string[];
@@ -385,27 +397,28 @@ declare class VimcordSlashCommandManager {
     unregisterGuild(options?: {
         guilds?: string[];
     }): Promise<void>;
-    registerGlobal(options?: {
-        commands?: string[];
-        fuzzyCommands?: string[];
-    }): Promise<void>;
     unregisterGlobal(): Promise<void>;
 }
+declare class VimcordSlashCommandManager extends VimcordAppCommandManager<CommandType.Slash> {
+    constructor(client: Vimcord);
+    importFrom(dir: string | string[], replaceAll?: boolean): Promise<Map<string, SlashCommandBuilder>>;
+}
+declare class VimcordContextCommandManager extends VimcordAppCommandManager<CommandType.Context> {
+    constructor(client: Vimcord);
+    importFrom(dir: string | string[], replaceAll?: boolean): Promise<Map<string, ContextCommandBuilder>>;
+}
 declare class VimcordPrefixCommandManager {
-    client: Vimcord;
+    private client;
     commands: Map<string, VimcordCommandBuilderByType<CommandType.Prefix>>;
     constructor(client: Vimcord);
-    get(name: string): PrefixCommandBuilder | undefined;
-    getByAlias(alias: string): PrefixCommandBuilder | undefined;
-    /** Import command modules that end with `.prefix` */
+    resolve(trigger: string): PrefixCommandBuilder | undefined;
     importFrom(dir: string | string[], replaceAll?: boolean): Promise<Map<string, PrefixCommandBuilder>>;
 }
-declare class VimcordContextCommandManager {
-    client: Vimcord;
-    commands: Map<string, VimcordCommandBuilderByType<CommandType.Context>>;
+declare class VimcordCommandManager {
+    readonly slash: VimcordSlashCommandManager;
+    readonly prefix: VimcordPrefixCommandManager;
+    readonly context: VimcordContextCommandManager;
     constructor(client: Vimcord);
-    /** Import command modules that end with `.ctx` */
-    importFrom(dir: string | string[], replaceAll?: boolean): Promise<Map<string, ContextCommandBuilder>>;
 }
 
 type EventParameters<T extends keyof ClientEvents> = [client: Vimcord<true>, ...args: ClientEvents[T]];
@@ -544,10 +557,17 @@ interface VimcordToolsConfig {
     embedColor: ColorResolvable[];
     embedColorDev: ColorResolvable[];
     timeouts: {
+        collectorTimeout: number;
+        collectorIdle: number;
         pagination: number;
         prompt: number;
         modalSubmit: number;
     };
+    collector: {
+        notAParticipantMessage: string;
+        userLockMessage: string;
+        notAParticipantWarningCooldown: number;
+    };
     paginator: {
         notAParticipantMessage: string;
         jumpableThreshold: number;
@@ -575,10 +595,17 @@ declare function createToolsConfig(options?: PartialDeep<VimcordToolsConfig>): V
     embedColor?: ColorResolvable[] | undefined;
     embedColorDev?: ColorResolvable[] | undefined;
     timeouts?: {
+        collectorTimeout?: number | undefined;
+        collectorIdle?: number | undefined;
         pagination?: number | undefined;
         prompt?: number | undefined;
         modalSubmit?: number | undefined;
     } | undefined;
+    collector?: {
+        notAParticipantMessage?: string | undefined;
+        userLockMessage?: string | undefined;
+        notAParticipantWarningCooldown?: number | undefined;
+    } | undefined;
     paginator?: {
         notAParticipantMessage?: string | undefined;
         jumpableThreshold?: number | undefined;
@@ -649,14 +676,14 @@ declare class BetterContainer {
         divider?: boolean;
         spacing?: number;
     }): this;
-    addText(text: string | string[]): this;
+    addText(text: string | (string | null | undefined)[]): this;
     addMedia(...media: {
         url: string | string[];
         spoiler?: boolean;
         description?: string;
     }[]): this;
     addSection(data: {
-        text?: string | string[];
+        text?: string | (string | null | undefined)[];
         button?: Partial<ButtonComponentData>;
         thumbnail?: Partial<APIThumbnailComponent>;
     }): this;
@@ -665,6 +692,9 @@ declare class BetterContainer {
     send(handler: SendHandler, options?: DynaSendOptions): Promise<Message | null>;
 }
 
+type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
 type SendableComponent = ContainerBuilder | BetterContainer | ActionRowBuilder<MessageActionRowComponentBuilder>;
 type RequiredDynaSendOptions = DynaSendOptions & ({
     content: string;
@@ -673,7 +703,7 @@ type RequiredDynaSendOptions = DynaSendOptions & ({
 } | {
     components: DynaSendOptions["components"];
 } | {
-    files: BaseMessageOptions["files"];
+    files: Mutable<BaseMessageOptions["files"]>;
 } | {
     stickers: StickerResolvable[];
 } | {
@@ -691,7 +721,7 @@ interface DynaSendOptions {
     /** Components to send with the message */
     components?: SendableComponent[];
     /** Attachments to send with the message */
-    files?: BaseMessageOptions["files"];
+    files?: Mutable<BaseMessageOptions["files"]>;
     /** Stickers to send with the message */
     stickers?: StickerResolvable[];
     /** Send a poll */
@@ -749,10 +779,10 @@ interface BetterEmbedData {
     author?: string | BetterEmbedAuthor | null;
     title?: string | BetterEmbedTitle | null;
     thumbnailUrl?: string | null;
-    description?: string | string[] | null;
+    description?: string | (string | null | undefined)[] | null;
     imageUrl?: string | null;
     footer?: string | BetterEmbedFooter | null;
-    fields?: APIEmbedField[];
+    fields?: (APIEmbedField | null | undefined)[];
     color?: ColorResolvable | ColorResolvable[] | null;
     timestamp?: number | boolean | Date | null;
     acf?: boolean;
@@ -945,60 +975,39 @@ declare enum RateLimitScope {
 }
 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?
-     * @default true */
-    enabled?: boolean;
-    conditions?: Array<(...args: BaseCommandParameters<T>) => boolean>;
-    permissions?: CommandPermissions;
-    metadata?: CommandMetadata;
-    rateLimit?: CommandRateLimitOptions<(...args: BaseCommandParameters<T>) => any>;
-    /** Log whenever a command is executed?
-     * @default true */
-    logExecution?: boolean;
-    beforeExecute?: (...args: BaseCommandParameters<T>) => any;
-    execute?: (...args: BaseCommandParameters<T>) => any;
-    afterExecute?: (result: any, ...args: BaseCommandParameters<T>) => any;
-    onMissingPermissions?: (results: CommandPermissionResults, ...args: BaseCommandParameters<T>) => any;
-    onConditionsNotMet?: (...args: BaseCommandParameters<T>) => any;
-    onUsedWhenDisabled?: (...args: BaseCommandParameters<T>) => any;
-    onRateLimit?: (...args: BaseCommandParameters<T>) => any;
-    onError?: (error: Error, ...args: BaseCommandParameters<T>) => any;
-}
-interface BaseCommandOptions<T extends CommandType> {
-    /** Is this command enabled?
-     * @default true */
+    /** Is this command enabled? @default true */
     enabled?: boolean;
     /** Custom conditions that must be met for this command to execute */
-    conditions?: Array<(...args: BaseCommandParameters<T>) => boolean>;
+    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>;
-}
-interface BaseAppCommandConfig {
-    /** Command deployment configuration */
-    deployment?: AppCommandDeployment;
-}
-interface BaseCommandFunctionConfig<T extends CommandType> {
-    /** Before command execution */
+    /** Log whenever a command is executed? @default 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;
-    /** After successful execution */
+    /** Executed after successful execution */
     afterExecute?: (result: any, ...args: BaseCommandParameters<T>) => any;
-    /** Executed when the rate limit is hit */
-    onRateLimit?: (...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;
@@ -1006,55 +1015,96 @@ interface CommandInternalRateLimitData {
     timestamp: number;
 }
 
-declare class BaseCommandBuilder<T extends CommandType, CommandConfig extends BaseCommandOptions<T> & BaseCommandFunctionConfig<T> = BaseCommandOptions<T> & BaseCommandFunctionConfig<T>> implements BaseCommandOptions<T>, BaseCommandFunctionConfig<T> {
+declare abstract class BaseCommandBuilder<T extends CommandType, O extends BaseCommandConfig<T> = BaseCommandConfig<T>> {
     readonly uuid: string;
     readonly commandType: T;
-    client?: Vimcord;
-    enabled: boolean;
-    conditions?: Array<(...args: BaseCommandParameters<T>) => boolean>;
-    permissions?: CommandPermissions;
-    metadata?: CommandMetadata;
-    rateLimit?: CommandRateLimitOptions<(...args: BaseCommandParameters<T>) => any>;
-    beforeExecute?: (...args: BaseCommandParameters<T>) => any;
-    execute?: (...args: BaseCommandParameters<T>) => any;
-    afterExecute?: (result: any, ...args: BaseCommandParameters<T>) => any;
-    onRateLimit?: (...args: BaseCommandParameters<T>) => any;
-    onMissingPermissions?: (results: CommandPermissionResults, ...args: BaseCommandParameters<T>) => any;
-    onConditionsNotMet?: (...args: BaseCommandParameters<T>) => any;
-    onUsedWhenDisabled?: (...args: BaseCommandParameters<T>) => any;
-    onError?: (error: Error, ...args: BaseCommandParameters<T>) => any;
-    private globalRateLimitData;
-    private userRateLimitData;
-    private guildRateLimitData;
-    private channelRateLimitData;
-    constructor(type: T, config: CommandConfig);
+    /** Local command configuration and hooks */
+    protected options: O;
+    /** Internal state for rate limiting across different scopes */
+    private readonly rlStores;
+    /** * Mapping of CommandTypes to their respective config keys in the Vimcord client
+     */
+    private readonly typeConfigMapping;
+    constructor(type: T, options?: O);
     private validateBaseConfig;
-    toConfig(): BaseCommandConfig<T>;
+    /**
+     * Resolves the final configuration by merging layers:
+     * Client Defaults < Client Type-Specific < Local Command Options
+     */
+    protected resolveConfig(client: Vimcord): O;
+    /**
+     * Executes the command lifecycle.
+     * Merges global client config with local command options at runtime.
+     */
+    run(client: Vimcord<true>, ...args: BaseCommandParameters<T>): Promise<void>;
+    /**
+     * Internal logic to determine if a command execution should be throttled.
+     * @param config The merged configuration to use for limits.
+     * @param ctx Extracted Discord context (User, Guild, Channel).
+     */
+    private isRateLimited;
+    /**
+     * Validates if the user has required permissions.
+     */
+    private checkPermissions;
+    /**
+     * Evaluates all custom conditions defined for the command.
+     */
+    private checkConditions;
+    /**
+     * Normalizes the trigger arguments into a standard context object.
+     */
+    private extractContext;
+    /**
+     * Resolves the storage key based on the RateLimit scope.
+     */
+    private getScopeKey;
+    /**
+     * Handles command errors by checking local handlers before falling back to global handlers.
+     */
+    private handleError;
+    /** Toggle command availability */
     setEnabled(enabled: boolean): this;
-    addConditions(...conditions: Array<(...args: BaseCommandParameters<CommandType>) => boolean>): this;
-    setConditions(conditions: Array<(...args: BaseCommandParameters<CommandType>) => boolean>): this;
-    setPermissions(permissions: CommandPermissions): this;
+    /** Merge new permission requirements into the existing ones */
+    setPermissions(perms: CommandPermissions): this;
+    /** Add custom logic checks that run before execution */
+    addConditions(...conditions: Array<(...args: BaseCommandParameters<T>) => boolean | Promise<boolean>>): this;
+    /** Set the primary command execution logic */
+    setExecute(fn: (...args: BaseCommandParameters<T>) => any): this;
+    /** * Set the custom conditions that must be met for this command to execute
+     */
+    setConditions(conditions: Array<(...args: BaseCommandParameters<T>) => boolean | Promise<boolean>>): this;
+    /** * Set the command metadata configuration
+     */
     setMetadata(metadata: CommandMetadata): this;
-    setRateLimit(options: CommandRateLimitOptions<(...args: BaseCommandParameters<CommandType>) => any>): this;
-    setBeforeExecute(callback: (...args: BaseCommandParameters<CommandType>) => any): this;
-    setExecute(callback: (...args: BaseCommandParameters<CommandType>) => any): this;
-    setAfterExecute(callback: (result: any, ...args: BaseCommandParameters<CommandType>) => any): this;
-    setOnRateLimit(callback: (...args: BaseCommandParameters<CommandType>) => any): this;
-    setOnMissingPermissions(callback: (results: CommandPermissionResults, ...args: BaseCommandParameters<CommandType>) => any): this;
-    setOnConditionsNotMet(callback: (...args: BaseCommandParameters<CommandType>) => any): this;
-    setOnUsedWhenDisabled(callback: (...args: BaseCommandParameters<CommandType>) => any): this;
-    setOnError(callback: (error: Error, ...args: BaseCommandParameters<CommandType>) => any): this;
-    getRateLimitInfo(user?: User, guild?: Guild, channel?: TextBasedChannel): {
-        executions: number;
-        timestamp: number;
-        isLimited: boolean;
-    } | null;
-    isRateLimited(user?: User | null, guild?: Guild | null, channel?: TextBasedChannel | null, updateExecutions?: boolean): boolean;
-    checkPermissions(client: Vimcord<true>, user: GuildMember | User, command: CommandInteraction | string): CommandPermissionResults;
-    checkConditions(...args: BaseCommandParameters<T>): Promise<boolean>;
-    _runPreflight(clientConfig: BaseCommandConfig<T>, command: CommandInteraction | string, ...args: BaseCommandParameters<T>): Promise<any>;
-    _runCabinCheck(clientConfig: BaseCommandConfig<T>, ...args: BaseCommandParameters<T>): Promise<any>;
-    _runFlyAndLand(clientConfig: BaseCommandConfig<T>, ...args: BaseCommandParameters<T>): Promise<any>;
+    /** * Set the rate limiting options for this command
+     */
+    setRateLimit(options: CommandRateLimitOptions<(...args: BaseCommandParameters<T>) => any>): this;
+    /** * Set whether to log whenever this command is executed
+     * @default true
+     */
+    setLogExecution(log: boolean): this;
+    /** * Set the function to execute before the main command logic
+     */
+    setBeforeExecute(callback: (...args: BaseCommandParameters<T>) => any): this;
+    /** * Set the function to execute after successful command execution
+     */
+    setAfterExecute(callback: (result: any, ...args: BaseCommandParameters<T>) => any): this;
+    /** * Set the function to execute when the required permissions are not met
+     */
+    setOnMissingPermissions(callback: (results: CommandPermissionResults, ...args: BaseCommandParameters<T>) => any): this;
+    /** * Set the function to execute when the required conditions are not met
+     */
+    setOnConditionsNotMet(callback: (...args: BaseCommandParameters<T>) => any): this;
+    /** * Set the function to execute when this command is used when its disabled
+     */
+    setOnUsedWhenDisabled(callback: (...args: BaseCommandParameters<T>) => any): this;
+    /** * Set the function to execute when the rate limit is hit
+     */
+    setOnRateLimit(callback: (...args: BaseCommandParameters<T>) => any): this;
+    /** * Set a custom error handler for this command
+     */
+    setOnError(callback: (error: Error, ...args: BaseCommandParameters<T>) => any): this;
 }
 
 type ExtractReturn<T> = T extends (this: any, ...args: any) => infer R ? Awaited<R> : never;
@@ -1083,30 +1133,82 @@ declare class MongoSchemaBuilder<Definition extends object> {
     on<K extends keyof MongoSchemaEvents>(event: K, listener: (...args: MongoSchemaEvents[K]) => void): this;
     once<K extends keyof MongoSchemaEvents>(event: K, listener: (...args: MongoSchemaEvents[K]) => void): this;
     off<K extends keyof MongoSchemaEvents>(event: K, listener: (...args: MongoSchemaEvents[K]) => void): this;
-    execute<T extends (...args: any) => Promise<any>>(fn: T): Promise<ExtractReturn<T> | undefined>;
+    /** Execute a function while ensuring the connection is ready. On error it will retry using an exponential backoff. */
+    execute<T extends (...args: any) => any>(fn: T): Promise<ExtractReturn<T> | undefined>;
     createHexId(bytes: number, path: keyof Require_id<Definition>, maxRetries?: number): Promise<string | undefined>;
-    count(filter?: RootFilterQuery<Definition>): Promise<number | undefined>;
+    count(filter?: RootFilterQuery<Definition>, options?: mongo.CountOptions & MongooseBaseQueryOptions<Definition> & mongo.Abortable): Promise<number | undefined>;
     exists(filter: RootFilterQuery<Definition>): Promise<boolean | undefined>;
-    create(query: Partial<Require_id<Definition>>): Promise<(mongoose.Document<unknown, {}, Definition, {}, {}> & (mongoose.Require_id<Definition> extends infer T ? T extends mongoose.Require_id<Definition> ? T extends {
+    create(query: Partial<Require_id<Definition>>[], options?: CreateOptions): Promise<(mongoose.Document<unknown, {}, Definition, {}, {}> & (mongoose.Require_id<Definition> extends infer T ? T extends mongoose.Require_id<Definition> ? T extends {
         __v?: infer U;
     } ? T : T & {
         __v: number;
-    } : never : never)) | undefined>;
+    } : never : never))[]>;
     upsert(filter: RootFilterQuery<Definition>, query: Partial<Require_id<Definition>>, options?: QueryOptions<Definition>): Promise<(mongoose.Document<unknown, {}, Definition, {}, {}> & (mongoose.Require_id<Definition> extends infer T ? T extends mongoose.Require_id<Definition> ? T extends {
         __v?: infer U;
     } ? T : T & {
         __v: number;
     } : never : never)) | undefined>;
-    delete(filter: RootFilterQuery<Definition>): Promise<mongoose.mongo.DeleteResult | undefined>;
-    deleteAll(filter: RootFilterQuery<Definition>): Promise<mongoose.mongo.DeleteResult | undefined>;
-    distinct<K extends keyof Require_id<Definition> & string>(key: K, filter?: RootFilterQuery<Definition>): Promise<(K extends keyof Definition | mongoose.NestedPaths<Required<Definition>, keyof Definition> ? mongoose.WithoutUndefined<mongoose.Unpacked<mongoose.WithLevel1NestedPaths<Definition, keyof Definition>[K]>> : unknown)[] | undefined>;
+    delete(filter: RootFilterQuery<Definition>, options?: mongo.DeleteOptions & MongooseBaseQueryOptions<Definition>): Promise<mongoose.mongo.DeleteResult | undefined>;
+    deleteAll(filter: RootFilterQuery<Definition>, options?: mongo.DeleteOptions & MongooseBaseQueryOptions<Definition>): Promise<mongoose.mongo.DeleteResult | undefined>;
+    distinct<K extends keyof Require_id<Definition> & string>(key: K, filter?: RootFilterQuery<Definition>, options?: QueryOptions<Definition>): Promise<(K extends keyof Definition | mongoose.NestedPaths<Required<Definition>, keyof Definition> ? mongoose.WithoutUndefined<mongoose.Unpacked<mongoose.WithLevel1NestedPaths<Definition, keyof Definition>[K]>> : unknown)[] | undefined>;
     fetch<Options extends QueryOptions<Definition>>(filter?: RootFilterQuery<Definition>, projection?: ProjectionType<Definition>, options?: Options): Promise<LeanOrHydratedDocument<Definition, Options> | null | undefined>;
     fetchAll<Options extends QueryOptions<Definition>>(filter: RootFilterQuery<Definition>, projection?: ProjectionType<Definition>, options?: Options): Promise<LeanOrHydratedDocument<Definition, Options>[]>;
     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?: Parameters<Model<Definition>["updateMany"]>[2]): Promise<mongoose.UpdateWriteOpResult | undefined>;
+    updateAll(filter: RootFilterQuery<Definition>, update: UpdateQuery<Definition>, options?: mongo.UpdateOptions & MongooseUpdateQueryOptions<Definition>): Promise<mongoose.UpdateWriteOpResult | undefined>;
     aggregate<T extends any>(pipeline: PipelineStage[], options?: AggregateOptions): Promise<T[]>;
 }
 
+interface BetterCollectorOptions<T extends MessageComponentType> {
+    type?: T;
+    participants?: UserResolvable$1[];
+    idle?: number;
+    timeout?: number;
+    /** Run listeners in sequence, awaiting each other */
+    sequential?: boolean;
+    /** Prevent a user from triggering another interaction until their previous one is resolved */
+    userLock?: boolean;
+    max?: number;
+    maxComponents?: number;
+    maxUsers?: number;
+    onTimeout?: CollectorTimeoutType;
+    config?: VimcordToolsConfig;
+}
+interface ListenerOptions<ComponentType extends MessageComponentType = MessageComponentType, InGuild extends boolean = boolean> {
+    participants?: UserResolvable$1[];
+    defer?: boolean | {
+        update?: boolean;
+        ephemeral?: boolean;
+    };
+    finally?: (arg: MappedInteractionTypes<InGuild>[ComponentType]) => any;
+}
+declare enum CollectorTimeoutType {
+    DisableComponents = 0,
+    DeleteMessage = 1,
+    DoNothing = 2
+}
+declare class BetterCollector<ComponentType extends MessageComponentType, InGuild extends boolean = boolean> {
+    message?: Message;
+    collector?: InteractionCollector<MappedInteractionTypes<InGuild>[ComponentType]>;
+    options?: BetterCollectorOptions<ComponentType>;
+    private activeUsers;
+    private participantWarningCooldowns;
+    private config;
+    private events;
+    static create<T extends MessageComponentType>(message: Message | undefined | null, options: BetterCollectorOptions<T>): BetterCollector<T, boolean>;
+    private validateParticipant;
+    private build;
+    private setupListeners;
+    private handleListenerError;
+    constructor(message: Message | undefined | null, options?: BetterCollectorOptions<ComponentType>);
+    /** Triggers on any interaction */
+    on(fn: (interaction: MappedInteractionTypes<InGuild>[ComponentType]) => any, options?: ListenerOptions<ComponentType, InGuild>): this;
+    /** Triggers when the interaction's customId matches */
+    on(customId: string, fn: (interaction: MappedInteractionTypes<InGuild>[ComponentType]) => any, options?: ListenerOptions<ComponentType, InGuild>): this;
+    onEnd(fn: (collected: MappedInteractionTypes<InGuild>[ComponentType][], reason: string) => any, options?: ListenerOptions): this;
+    /** Manually stop the collector and trigger cleanup */
+    stop(reason?: string): void;
+}
+
 type _TextInputComponentData = Partial<APITextInputComponent> & _LabelComponentData;
 type _StringSelectComponentData = Partial<APIStringSelectComponent> & _LabelComponentData;
 type _ChannelSelectComponentData = Partial<APIChannelSelectComponent> & _LabelComponentData;
@@ -1188,7 +1290,7 @@ declare class BetterModal {
     showAndAwait<T extends Record<string, any> = Record<string, string>>(interaction: Interaction, options?: Omit<AwaitModalSubmitOptions<ModalSubmitInteraction>, "filter">): Promise<ModalSubmitResult<T> | null>;
 }
 
-type SinglePageResolvable = string | EmbedResolvable | ContainerBuilder | BetterContainer;
+type SinglePageResolvable = string | EmbedResolvable | ContainerBuilder | BetterContainer | AttachmentBuilder;
 type PageResolvable = SinglePageResolvable | EmbedResolvable[];
 type Chapter = PageResolvable[];
 interface PageIndex {
@@ -1197,6 +1299,8 @@ interface PageIndex {
 }
 interface ChapterData extends Omit<SelectMenuComponentOptionData, "value"> {
     value?: string;
+    /** Optional attachments mapped to each nested page index */
+    files?: (AttachmentBuilder | undefined)[];
 }
 interface PaginationEvent {
     beforeChapterChange: [chapterIndex: number];
@@ -1210,7 +1314,8 @@ interface PaginationEvent {
     last: [page: PageResolvable, index: PageIndex];
     collect: [interaction: StringSelectMenuInteraction | ButtonInteraction, page: PageResolvable, index: PageIndex];
     react: [reaction: MessageReaction, user: User, page: PageResolvable, index: PageIndex];
-    timeout: [message: Message];
+    preTimeout: [message: Message];
+    postTimeout: [message: Message];
 }
 interface PaginatorOptions {
     /** @default {@link PaginationType.Short} */
@@ -1223,7 +1328,6 @@ interface PaginatorOptions {
     /** @default false */
     dynamic?: boolean;
     timeout?: number;
-    /** @default {@link PaginationTimeoutType.ClearComponents} */
     onTimeout?: PaginationTimeoutType;
     config?: VimcordToolsConfig;
 }
@@ -1270,12 +1374,14 @@ declare enum PaginationType {
 declare enum PaginationTimeoutType {
     DisableComponents = 0,
     ClearComponents = 1,
-    DeleteMessage = 2
+    DeleteMessage = 2,
+    DoNothing = 3
 }
 declare class Paginator {
     chapters: {
         id: string;
         pages: Chapter;
+        files?: (AttachmentBuilder | undefined)[];
     }[];
     private options;
     private config;
@@ -1325,6 +1431,7 @@ interface PromptOptions {
     content?: string;
     embed?: EmbedResolvable;
     container?: ContainerBuilder | BetterContainer;
+    textOnly?: boolean;
     buttons?: {
         confirm?: ButtonBuilder | ((builder: ButtonBuilder) => ButtonBuilder) | Partial<APIButtonComponent>;
         reject?: ButtonBuilder | ((builder: ButtonBuilder) => ButtonBuilder) | Partial<APIButtonComponent>;
@@ -1346,6 +1453,7 @@ declare class Prompt {
     readonly content?: string;
     readonly embed: EmbedResolvable;
     readonly container?: ContainerBuilder | BetterContainer;
+    readonly textOnly?: boolean;
     readonly buttons: {
         confirm: ButtonBuilder;
         reject: ButtonBuilder;
@@ -1490,4 +1598,4 @@ declare function sendCommandErrorEmbed(client: Vimcord, error: Error, guild: Gui
 
 declare function validateCommandPermissions(permissions: CommandPermissions, client: Vimcord<true>, user: GuildMember | User, command: CommandInteraction | string): CommandPermissionResults;
 
-export { type AnySlashCommandBuilder, type AppCommandDeployment, type BaseAppCommandConfig, BaseCommandBuilder, type BaseCommandConfig, type BaseCommandFunctionConfig, type BaseCommandOptions, type BaseCommandParameters, type BetterChannelSelectComponent, 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, type CommandErrorMessageConfig, type CommandInternalRateLimitData, type CommandMetadata, type CommandPermissionResults, type CommandPermissions, type CommandRateLimitOptions, CommandType, ContextCommandBuilder, type CustomButton, DynaSend, type DynaSendOptions, type EmbedResolvable, EventBuilder, type EventConfig, type EventDeployment, type EventMetadata, type EventParameters, type EventRateLimitOptions, type ExtractReturn, type FetchedChannel, type FetchedMessageMention, type GetMessageMentionOptions, type InteractionBasedSendHandler, type InteractionResolveable, type LeanOrHydratedDocument, LogLevel, Logger, type LoggerOptions, type MentionType, MissingPermissionReason, type ModalSubmitResult, MongoDatabase, MongoSchemaBuilder, type MongoSchemaEvents, type MongoSchemaOptions, type PageIndex, type PageResolvable, type PaginationEvent, PaginationTimeoutType, PaginationType, Paginator, type PaginatorData, type PaginatorOptions, PrefixCommandBuilder, Prompt, type PromptOptions, PromptResolveType, type PromptResult, RateLimitScope, type RequiredDynaSendOptions, type SendHandler, SendMethod, type SendableComponent, type SendableTextChannel, type SinglePageResolvable, SlashCommandBuilder, StatusType, type UserResolvable, Vimcord, type VimcordAppConfig, VimcordCLI, type VimcordCLIOptions, type VimcordClientStatus, type VimcordCommandBuilderByType, VimcordCommandManager, type VimcordConfig, type VimcordConfigOptions, type VimcordContextCommandConfig, VimcordContextCommandManager, type VimcordDatabaseManager, VimcordEventManager, type VimcordFeatures, type VimcordPrefixCommandConfig, VimcordPrefixCommandManager, type VimcordSlashCommandConfig, VimcordSlashCommandManager, type VimcordStaffConfig, VimcordStatusManager, type VimcordToolsConfig, __zero, cleanMention, clientInstances, createClient, createMongoSchema, createToolsConfig, createVimcordAppConfig, createVimcordContextCommandConfig, createVimcordPrefixCommandConfig, createVimcordSlashCommandConfig, createVimcordStaffConfig, createVimcordStatusConfig, defineGlobalToolsConfig, dynaSend, fetchChannel, fetchGuild, fetchMember, fetchMessage, fetchRole, fetchUser, formatThousands, getCallerFileName, getClientInstances, getFirstMentionId, getMessageMention, getProcessDir, globalVimcordToolsConfig, importModulesFromDir, initCLI, isMentionOrSnowflake, logger, pickRandom, prompt, retryExponentialBackoff, sendCommandErrorEmbed, useClient, useMongoDatabase, useReadyClient, validateCommandPermissions };
+export { type AnySlashCommandBuilder, type AppCommandDeployment, type BaseAppCommandConfig, BaseCommandBuilder, type BaseCommandConfig, 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 CommandErrorMessageConfig, type CommandInternalRateLimitData, type CommandMetadata, type CommandPermissionResults, type CommandPermissions, type CommandRateLimitOptions, CommandType, ContextCommandBuilder, type ContextCommandConfig, type CustomButton, DynaSend, type DynaSendOptions, type EmbedResolvable, EventBuilder, type EventConfig, type EventDeployment, 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, MongoSchemaBuilder, type MongoSchemaEvents, type MongoSchemaOptions, type PageIndex, type PageResolvable, type PaginationEvent, PaginationTimeoutType, PaginationType, Paginator, type PaginatorData, type PaginatorOptions, PrefixCommandBuilder, type PrefixCommandConfig, Prompt, type PromptOptions, PromptResolveType, type PromptResult, RateLimitScope, type RequiredDynaSendOptions, type SendHandler, SendMethod, type SendableComponent, type SendableTextChannel, type SinglePageResolvable, SlashCommandBuilder, type SlashCommandConfig, StatusType, type UserResolvable, Vimcord, type VimcordAppConfig, VimcordCLI, type VimcordCLIOptions, type VimcordClientStatus, type VimcordCommandBuilderByType, VimcordCommandManager, type VimcordConfig, type VimcordConfigOptions, type VimcordContextCommandConfig, VimcordContextCommandManager, type VimcordDatabaseManager, VimcordEventManager, type VimcordFeatures, type VimcordPrefixCommandConfig, VimcordPrefixCommandManager, type VimcordSlashCommandConfig, VimcordSlashCommandManager, type VimcordStaffConfig, VimcordStatusManager, type VimcordToolsConfig, __zero, cleanMention, clientInstances, createClient, createMongoSchema, createMongoSession, createToolsConfig, createVimcordAppConfig, createVimcordContextCommandConfig, createVimcordPrefixCommandConfig, createVimcordSlashCommandConfig, createVimcordStaffConfig, createVimcordStatusConfig, defineGlobalToolsConfig, dynaSend, fetchChannel, fetchGuild, fetchMember, fetchMessage, fetchRole, fetchUser, formatThousands, getCallerFileName, getClientInstances, getFirstMentionId, getMessageMention, getProcessDir, globalVimcordToolsConfig, importModulesFromDir, initCLI, isMentionOrSnowflake, logger, pickRandom, prompt, retryExponentialBackoff, sendCommandErrorEmbed, useClient, useMongoDatabase, useReadyClient, useReadyMongoDatabase, validateCommandPermissions };