vimcord 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1493 @@
+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 { DotenvConfigOptions } from 'dotenv';
+import mongoose, { QueryOptions, HydratedDocument, Require_id, SchemaDefinition, Schema, Model, RootFilterQuery, ProjectionType, UpdateQuery, PipelineStage, AggregateOptions } from 'mongoose';
+import { PartialDeep } from 'type-fest';
+import { ScheduledTask } from 'node-cron';
+import EventEmitter from 'node:events';
+import { Interface } from 'node:readline';
+
+type AnySlashCommandBuilder = SlashCommandBuilder$1 | SlashCommandOptionsOnlyBuilder | SlashCommandSubcommandBuilder | SlashCommandSubcommandsOnlyBuilder | SlashCommandSubcommandGroupBuilder;
+interface CommandPermissions {
+    /** Permissions the user is required to have to use this command
+     * @remarks If this is a slash command, use the builder's `setDefaultMemberPermissions` option instead */
+    user?: PermissionResolvable[];
+    /** Permissions the bot is required to have to execute this command */
+    bot?: PermissionResolvable[];
+    /** Roles allowed to use this command by ID */
+    roles?: string[];
+    /** Only allow these users to use this command by ID */
+    userWhitelist?: string[];
+    /** Users blacklisted from using this command by ID */
+    userBlacklist?: string[];
+    /** Roles blacklisted from using this command by ID */
+    roleBlacklist?: string[];
+    /** Should this command only be usable in guilds?
+     * @remarks If this is a slash command, use the builder's `setContexts` option instead */
+    guildOnly?: boolean;
+    /** Should only the guild owner be allowed to use this command? */
+    guildOwnerOnly?: boolean;
+    /** Should only the bot owner be allowed to use this command? */
+    botOwnerOnly?: boolean;
+    /** Should only the bot staff (including bot owner) be allowed to use this command? */
+    botStaffOnly?: boolean;
+}
+interface CommandMetadata {
+    /** Command category for categorizing commands */
+    category?: string;
+    /** Command tags for categorizing commands */
+    tags?: string[];
+    /** Command usage examples */
+    examples?: string[];
+    /** Command emoji */
+    emoji?: string;
+    /** Will this command show up in help commands? @defaultValue `false` */
+    hidden?: boolean;
+}
+interface AppCommandDeployment {
+    /** Specific guild IDs to deploy to */
+    guilds?: string[];
+    /** Whether to deploy globally */
+    global?: boolean;
+    /** Deployment environments */
+    environments?: ("development" | "production")[];
+}
+interface CommandRateLimitOptions<OnRateLimitParams extends (...args: any) => any = (...args: any) => any> {
+    /** Max executions per interval */
+    max: number;
+    /** Interval in milliseconds */
+    interval: number;
+    /** Rate limit scope */
+    scope: RateLimitScope;
+    /** What to do when rate limited */
+    onRateLimit?: OnRateLimitParams;
+}
+interface CommandPermissionResults {
+    validated: boolean;
+    failReason?: MissingPermissionReason;
+    missingUserPermissions?: PermissionResolvable[];
+    missingBotPermissions?: PermissionResolvable[];
+    missingRoles?: string[];
+    blacklistedUser?: string;
+    blacklistedRole?: string;
+}
+
+interface MongoConnectionOptions {
+    /** The maximum number of attempts to connect to MongoDB @defaultValue `3` */
+    maxRetries?: number;
+}
+declare function useMongoDatabase(index?: number): Promise<MongoDatabase>;
+declare class MongoDatabase {
+    client: Vimcord;
+    readonly name: string;
+    readonly uuid: string;
+    readonly index: number;
+    private uri;
+    mongoose: mongoose.Mongoose;
+    private eventEmitter;
+    private isReady;
+    private isConnecting;
+    constructor(client: Vimcord, options?: mongoose.MongooseOptions);
+    waitForReady(): Promise<boolean>;
+    connect(uri?: string, connectionOptions?: mongoose.ConnectOptions, options?: MongoConnectionOptions): Promise<boolean>;
+}
+
+type VimcordDatabaseManager = MongoDatabase;
+
+interface VimcordAppConfig {
+    devMode: boolean;
+    name: string;
+    appVersion: string;
+    /** Enable verbose console logs?
+     * @default false */
+    verbose: boolean;
+    /** Disable the vimcord client banner on startup
+     * @default false */
+    disableBanner: boolean;
+}
+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> {
+    /** @default ! */
+    defaultPrefix: string;
+    /** @default true */
+    allowMentionAsPrefix: boolean;
+    /** @default true */
+    allowCaseInsensitiveCommandNames: boolean;
+}
+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 DEFAULT_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 DEFAULT_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 DEFAULT_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;
+
+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 VimcordStatusManagerEvents = {
+    changed: [ClientActivity];
+    cleared: [];
+    rotation: [ClientActivity];
+    rotationPaused: [ScheduledTask];
+    rotationStarted: [ScheduledTask];
+    rotationDestroyed: [];
+};
+declare class VimcordStatusManager {
+    client: Vimcord;
+    logger: Logger;
+    emitter: EventEmitter<VimcordStatusManagerEvents>;
+    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 ContextCommandConfig extends BaseCommandOptions<CommandType.Context>, BaseAppCommandConfig, BaseCommandFunctionConfig<CommandType.Context> {
+    /** Context menu command builder */
+    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 validateBuilder;
+    private validateConfig;
+    toConfig(): ContextCommandConfig;
+    setBuilder(builder: ContextMenuCommandBuilder | ((builder: ContextMenuCommandBuilder) => ContextMenuCommandBuilder)): this;
+    setDeferReply(defer: boolean | {
+        ephemeral?: boolean;
+    }): this;
+    setDeployment(deployment: AppCommandDeployment): this;
+    executeCommand(client: Vimcord<true>, interaction: ContextMenuCommandInteraction): Promise<any>;
+}
+
+interface PrefixCommandConfig extends BaseCommandOptions<CommandType.Prefix>, BaseCommandFunctionConfig<CommandType.Prefix> {
+    name: string;
+    aliases?: string[];
+    description?: string;
+}
+declare class PrefixCommandBuilder extends BaseCommandBuilder<CommandType.Prefix, PrefixCommandConfig> {
+    name: string;
+    aliases?: string[];
+    description?: string;
+    constructor(config: PrefixCommandConfig);
+    private validateConfig;
+    toConfig(): PrefixCommandConfig;
+    executeCommand(client: Vimcord<true>, message: Message): Promise<any>;
+}
+
+interface SlashCommandConfig extends BaseCommandOptions<CommandType.Slash>, BaseAppCommandConfig, BaseCommandFunctionConfig<CommandType.Slash> {
+    /** Slash command builder */
+    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?: {
+        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;
+    constructor(config: SlashCommandConfig);
+    private validateBuilder;
+    private validateConfig;
+    toConfig(): SlashCommandConfig;
+    setBuilder(builder: AnySlashCommandBuilder | ((builder: SlashCommandBuilder$1) => AnySlashCommandBuilder)): this;
+    setDeferReply(defer: boolean | {
+        ephemeral?: boolean;
+    }): 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>;
+}
+
+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;
+    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>>;
+    registerGuild(options?: {
+        commands?: string[];
+        fuzzyCommands?: string[];
+        guilds?: string[];
+    }): Promise<void>;
+    unregisterGuild(options?: {
+        guilds?: string[];
+    }): Promise<void>;
+    registerGlobal(options?: {
+        commands?: string[];
+        fuzzyCommands?: string[];
+    }): Promise<void>;
+    unregisterGlobal(): Promise<void>;
+}
+declare class VimcordPrefixCommandManager {
+    client: Vimcord;
+    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` */
+    importFrom(dir: string | string[], replaceAll?: boolean): Promise<Map<string, PrefixCommandBuilder>>;
+}
+declare class VimcordContextCommandManager {
+    client: Vimcord;
+    commands: Map<string, VimcordCommandBuilderByType<CommandType.Context>>;
+    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]];
+
+interface EventMetadata {
+    /** Event category */
+    category?: string;
+    /** Tags for categorizing events */
+    tags?: string[];
+}
+interface EventDeployment {
+    /** Deployment environments */
+    environments?: ("development" | "production")[];
+}
+interface EventRateLimitOptions<T extends keyof ClientEvents> {
+    /** Max executions per interval */
+    max: number;
+    /** Interval in milliseconds */
+    interval: number;
+    /** What to do when rate limited */
+    onRateLimit?: (...args: EventParameters<T>) => any;
+}
+
+interface EventConfig<T extends keyof ClientEvents> {
+    /** Discord.js event name */
+    event: T;
+    /** Human-readable name for the event */
+    name?: string;
+    /** Whether this event will be executed or not @defaultValue `true` */
+    enabled?: boolean;
+    /** Whether this event will be executed only once or not */
+    once?: boolean;
+    /** Priority for event execution order (lower = earlier) @defaultValue `0` */
+    priority?: number;
+    /** Conditions that must be met for this event to execute */
+    conditions?: Array<(...args: EventParameters<T>) => boolean>;
+    /** Event metadata */
+    metadata?: EventMetadata;
+    /** Event deployment */
+    deployment?: EventDeployment;
+    /** Rate limiting options */
+    rateLimit?: EventRateLimitOptions<T>;
+    /** Before event execution */
+    beforeExecute?: (...args: EventParameters<T>) => any;
+    /** The function that will be executed */
+    execute?: (...args: EventParameters<T>) => any;
+    /** After successful execution */
+    afterExecute?: (result: any, ...args: EventParameters<T>) => any;
+    /** Custom error handler */
+    onError?: (error: Error, ...args: EventParameters<T>) => any;
+}
+
+declare class EventBuilder<T extends keyof ClientEvents = keyof ClientEvents> implements EventConfig<T> {
+    readonly uuid: string;
+    event: T;
+    name: string;
+    enabled: boolean;
+    once: boolean;
+    priority: number;
+    conditions: ((client: Vimcord<true>, ...args: ClientEvents[T]) => boolean)[] | undefined;
+    metadata: EventMetadata | undefined;
+    deployment: EventDeployment | undefined;
+    rateLimit: EventRateLimitOptions<T> | undefined;
+    beforeExecute: ((client: Vimcord<true>, ...args: ClientEvents[T]) => any) | undefined;
+    execute: ((client: Vimcord<true>, ...args: ClientEvents[T]) => any) | undefined;
+    afterExecute: ((result: any, client: Vimcord<true>, ...args: ClientEvents[T]) => any) | undefined;
+    onError: ((error: Error, client: Vimcord<true>, ...args: ClientEvents[T]) => any) | undefined;
+    private rateLimitData;
+    static create<T extends keyof ClientEvents>(event: T, name?: string): EventBuilder<T>;
+    constructor(config: EventConfig<T>);
+    validate(): void;
+    clone(): EventBuilder<T>;
+    toConfig(): EventConfig<T>;
+    setEvent(event: T): this;
+    setName(name: string): this;
+    setEnabled(enabled: boolean): this;
+    enable(): this;
+    disable(): this;
+    setOnce(once?: boolean): this;
+    setPriority(priority: number): this;
+    addCondition(condition: (...args: EventParameters<T>) => boolean): this;
+    setConditions(conditions: Array<(...args: EventParameters<T>) => boolean>): this;
+    setMetadata(metadata: EventMetadata): this;
+    setDeployment(deployment: EventDeployment): this;
+    setRateLimit(options: EventRateLimitOptions<T>): this;
+    setBeforeExecute(beforeExecute: (...args: EventParameters<T>) => Promise<any> | any): this;
+    setExecute(execute: (...args: EventParameters<T>) => Promise<any> | any): this;
+    setAfterExecute(afterExecute: (result: any, ...args: EventParameters<T>) => Promise<any> | any): this;
+    setOnError(onError: (error: Error, ...args: EventParameters<T>) => Promise<any> | any): this;
+    getRateLimitInfo(): {
+        executions: number;
+        timestamp: number;
+        isLimited: boolean;
+    } | null;
+    resetRateLimit(): this;
+    isRateLimited(updateExecutions?: boolean): boolean;
+    checkConditions(...args: EventParameters<T>): Promise<boolean>;
+    executeEvent(...args: EventParameters<T>): Promise<any>;
+}
+
+declare class VimcordEventManager {
+    client: Vimcord;
+    events: Map<string, EventBuilder<any>>;
+    logger: Logger;
+    constructor(client: Vimcord);
+    register<T extends keyof ClientEvents>(...events: EventBuilder<T>[]): void;
+    unregister(...names: string[]): void;
+    clear(): void;
+    get(name: string): EventBuilder | undefined;
+    getByTag(tag: string): EventBuilder[];
+    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
+}
+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 VimcordToolsConfig {
+    devMode: boolean;
+    embedColor: ColorResolvable[];
+    embedColorDev: ColorResolvable[];
+    timeouts: {
+        pagination: number;
+        prompt: number;
+        modalSubmit: number;
+    };
+    paginator: {
+        notAParticipantMessage: string;
+        jumpableThreshold: number;
+        longThreshold: number;
+        buttons: Record<"first" | "back" | "jump" | "next" | "last", {
+            label: string;
+            emoji: {
+                animated?: boolean;
+                name: string;
+                id: string;
+            };
+        }>;
+    };
+    prompt: {
+        defaultTitle: string;
+        defaultDescription: string;
+        confirmLabel: string;
+        rejectLabel: string;
+    };
+}
+declare const globalVimcordToolsConfig: VimcordToolsConfig;
+declare function defineGlobalToolsConfig(options: PartialDeep<VimcordToolsConfig>): void;
+declare function createToolsConfig(options?: PartialDeep<VimcordToolsConfig>): VimcordToolsConfig & {
+    devMode?: boolean | undefined;
+    embedColor?: ColorResolvable[] | undefined;
+    embedColorDev?: ColorResolvable[] | undefined;
+    timeouts?: {
+        pagination?: number | undefined;
+        prompt?: number | undefined;
+        modalSubmit?: number | undefined;
+    } | undefined;
+    paginator?: {
+        notAParticipantMessage?: string | undefined;
+        jumpableThreshold?: number | undefined;
+        longThreshold?: number | undefined;
+        buttons?: {
+            first?: {
+                label?: string | undefined;
+                emoji?: {
+                    animated?: boolean | undefined;
+                    name?: string | undefined;
+                    id?: string | undefined;
+                } | undefined;
+            } | undefined;
+            back?: {
+                label?: string | undefined;
+                emoji?: {
+                    animated?: boolean | undefined;
+                    name?: string | undefined;
+                    id?: string | undefined;
+                } | undefined;
+            } | undefined;
+            jump?: {
+                label?: string | undefined;
+                emoji?: {
+                    animated?: boolean | undefined;
+                    name?: string | undefined;
+                    id?: string | undefined;
+                } | undefined;
+            } | undefined;
+            next?: {
+                label?: string | undefined;
+                emoji?: {
+                    animated?: boolean | undefined;
+                    name?: string | undefined;
+                    id?: string | undefined;
+                } | undefined;
+            } | undefined;
+            last?: {
+                label?: string | undefined;
+                emoji?: {
+                    animated?: boolean | undefined;
+                    name?: string | undefined;
+                    id?: string | undefined;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+    prompt?: {
+        defaultTitle?: string | undefined;
+        defaultDescription?: string | undefined;
+        confirmLabel?: string | undefined;
+        rejectLabel?: string | undefined;
+    } | undefined;
+};
+
+interface BetterContainerData {
+    color?: string | string[] | null;
+    config?: VimcordToolsConfig;
+}
+declare class BetterContainer {
+    private container;
+    private data;
+    private config;
+    constructor(data?: BetterContainerData);
+    private configure;
+    build(): void;
+    addSeparator(options?: {
+        divider?: boolean;
+        spacing?: number;
+    }): this;
+    addText(text: string | string[]): this;
+    addMedia(...media: {
+        url: string | string[];
+        spoiler?: boolean;
+        description?: string;
+    }[]): this;
+    addSection(data: {
+        text?: string | string[];
+        button?: Partial<ButtonComponentData>;
+        thumbnail?: Partial<APIThumbnailComponent>;
+    }): this;
+    addActionRow(...components: ActionRowBuilder<MessageActionRowComponentBuilder>[]): this;
+    toJSON(): discord_js.APIContainerComponent;
+    send(handler: SendHandler, options?: DynaSendOptions): Promise<Message | null>;
+}
+
+type SendableComponent = ContainerBuilder | BetterContainer | ActionRowBuilder<MessageActionRowComponentBuilder>;
+type RequiredDynaSendOptions = DynaSendOptions & ({
+    content: string;
+} | {
+    embeds: DynaSendOptions["embeds"];
+} | {
+    components: DynaSendOptions["components"];
+} | {
+    files: BaseMessageOptions["files"];
+} | {
+    stickers: StickerResolvable[];
+} | {
+    poll: PollData;
+} | {
+    forward: ForwardOptions;
+});
+interface DynaSendOptions {
+    /** The method used to send the message - auto-detected if not provided */
+    sendMethod?: SendMethod;
+    /** Text content to send in the message */
+    content?: string;
+    /** Embeds to send with the message */
+    embeds?: EmbedResolvable[];
+    /** Components to send with the message */
+    components?: SendableComponent[];
+    /** Attachments to send with the message */
+    files?: BaseMessageOptions["files"];
+    /** Stickers to send with the message */
+    stickers?: StickerResolvable[];
+    /** Send a poll */
+    poll?: PollData;
+    /** Interaction flags */
+    flags?: InteractionReplyOptions["flags"];
+    /** Return the message after replying to or editing an interaction */
+    withResponse?: boolean;
+    /** Mention types allowed for the message */
+    allowedMentions?: MessageMentionOptions;
+    /** The message to reply to */
+    reply?: ReplyOptions;
+    /** Forward a message */
+    forward?: ForwardOptions;
+    /** Send as a TTS message */
+    tts?: boolean;
+    /** Time in milliseconds before deleting the message */
+    deleteAfter?: number;
+}
+declare class DynaSend {
+    private static forceArray;
+    private static isInteractionCallback;
+    private static filterFlags;
+    private static detectSendMethod;
+    private static validateSendMethod;
+    private static createMessageData;
+    private static executeSend;
+    private static scheduleDelete;
+    static send(handler: SendHandler, options: RequiredDynaSendOptions): Promise<Message | null>;
+}
+declare function dynaSend(handler: SendHandler, options: RequiredDynaSendOptions): Promise<Message | null>;
+
+interface BetterEmbedContext {
+    client?: Vimcord | Client | null;
+    interaction?: InteractionResolveable | null;
+    channel?: TextBasedChannel | null;
+    message?: Message | null;
+    user?: GuildMember | User | null;
+}
+interface BetterEmbedAuthor {
+    text: string;
+    icon?: string | boolean | null;
+    hyperlink?: string | null;
+}
+interface BetterEmbedTitle {
+    text: string;
+    hyperlink?: string | null;
+}
+interface BetterEmbedFooter {
+    text: string;
+    icon?: string | boolean | null;
+}
+interface BetterEmbedData {
+    context?: BetterEmbedContext | null;
+    author?: string | BetterEmbedAuthor | null;
+    title?: string | BetterEmbedTitle | null;
+    thumbnailUrl?: string | null;
+    description?: string | string[] | null;
+    imageUrl?: string | null;
+    footer?: string | BetterEmbedFooter | null;
+    fields?: APIEmbedField[];
+    color?: ColorResolvable | ColorResolvable[] | null;
+    timestamp?: number | boolean | Date | null;
+    acf?: boolean;
+    config?: VimcordToolsConfig;
+}
+declare class BetterEmbed {
+    private embed;
+    private data;
+    private config;
+    /** A powerful wrapper for `EmbedBuilder` that introduces useful features
+     *
+     * Auto-shorthand context formatting (_ACF_) is enabled by default
+     *
+     * All functions utilize _ACF_ unless `BetterEmbed.acf` is set to `false`
+     *
+     * ___Use a blackslash___ `\` ___to escape any context___
+     *
+     * \- - - Author Context - - -
+     * - __`$USER`__: _author's mention (@xsqu1znt)_
+     * - __`$USER_NAME`__: _author's username_
+     * - __`$DISPLAY_NAME`__: _author's display name (requires `GuildMember` context)_
+     * - __`$USER_AVATAR`__: _author's avatar_
+     *
+     * \- - - Client Context - - -
+     *
+     * - __`$BOT_AVATAR`__: _bot's avatar_
+     *
+     * \- - - Shorthand Context - - -
+     * - __`$YEAR`__: _YYYY_
+     * - __`$MONTH`__: _MM_
+     * - __`$DAY`__: _DD_
+     * - __`$year`__: _YY_
+     * - __`$month`__: _M or MM_
+     * - __`$day`__: _D or DD_ */
+    constructor(data?: BetterEmbedData);
+    private build;
+    private normalizeData;
+    private getContextUser;
+    private getContextClient;
+    private applyContextFormatting;
+    private configureEmbed;
+    setAuthor(author: string | BetterEmbedAuthor | null): this;
+    setTitle(title: string | BetterEmbedTitle | null): this;
+    setDescription(description: string | null): this;
+    setThumbnail(url: string | null): this;
+    setImage(url: string | null): this;
+    setFooter(footer: string | BetterEmbedFooter | null): this;
+    setColor(color: ColorResolvable | ColorResolvable[] | null): this;
+    setTimestamp(timestamp: number | boolean | Date | null): this;
+    addFields(fields: APIEmbedField[]): this;
+    setFields(fields: APIEmbedField[]): this;
+    spliceFields(index: number, deleteCount: number, ...fields: APIEmbedField[]): this;
+    clone(overrides?: Partial<BetterEmbedData>): BetterEmbed;
+    toJSON(): APIEmbed;
+    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;
+    /** @default config.staff.mainServer.inviteUrl */
+    inviteUrl?: string;
+    /** The support server invite button label @default "Support Server" */
+    inviteButtonLabel?: string;
+    /** The error details button label @default "Details" */
+    detailButtonLabel?: string;
+    /** @default 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;
+}
+interface VimcordFeatures {
+    /** Use global process error handlers @defaultValue `false` */
+    useGlobalErrorHandlers?: boolean;
+    /** Use our default prefix command handler @defaultValue `true` */
+    useDefaultPrefixCommandHandler?: boolean;
+    /** Use our default slash command handler @defaultValue `true` */
+    useDefaultSlashCommandHandler?: boolean;
+    /** 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
+     * ```ts
+     * try {
+     *     // Execute the command
+     *     return command.executeCommand(client, message);
+     * } catch (err) {
+     *     // Send the error embed, this already handles the feature configuration
+     *     sendCommandErrorEmbed(client, err as Error, message.guild, message);
+     *     // Re-throw the error so it can be handled by an error handler
+     *     throw err;
+     * }
+     * ``` */
+    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[];
+    };
+}
+interface VimcordConfig {
+    app: VimcordAppConfig;
+    staff: VimcordStaffConfig;
+    slashCommands: VimcordSlashCommandConfig;
+    prefixCommands: VimcordPrefixCommandConfig;
+    contextCommands: VimcordContextCommandConfig;
+}
+declare const clientInstances: Vimcord[];
+declare class Vimcord<Ready extends boolean = boolean> extends Client<Ready> {
+    readonly uuid: string;
+    readonly index: number;
+    readonly clientOptions: ClientOptions;
+    readonly features: VimcordFeatures;
+    readonly config: VimcordConfig;
+    status: VimcordStatusManager;
+    events: VimcordEventManager;
+    commands: VimcordCommandManager;
+    database?: VimcordDatabaseManager;
+    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;
+    constructor(options: ClientOptions, features?: VimcordFeatures, config?: PartialDeep<VimcordConfig>);
+    /** Returns the options, features, and config of this client */
+    toJSON(): {
+        options: ClientOptions;
+        features: VimcordFeatures;
+        config: VimcordConfig;
+    };
+    /** Make 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;
+    addEventModules(dir: string | string[], replaceAll?: boolean): Promise<this>;
+    addSlashCommandModules(dir: string | string[], replaceAll?: boolean): Promise<this>;
+    addPrefixCommandModules(dir: string | string[], replaceAll?: boolean): Promise<this>;
+    addContextCommandModules(dir: string | string[], replaceAll?: boolean): Promise<this>;
+    useDatabase(database: VimcordDatabaseManager): Promise<boolean>;
+    whenReady(): Promise<Vimcord<true>>;
+    build(): Promise<this>;
+    /** Automatically uses `process.env.TOKEN` or `process.env.TOKEN_DEV` if token isn't provided */
+    start(token?: string): Promise<string | null>;
+    start(preHook?: (client: Vimcord) => any): Promise<string | null>;
+    start(token?: string, preHook?: (client: Vimcord) => any): Promise<string | null>;
+    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?
+     * @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 */
+    enabled?: boolean;
+    /** Custom conditions that must be met for this command to execute */
+    conditions?: Array<(...args: BaseCommandParameters<T>) => 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 */
+    beforeExecute?: (...args: BaseCommandParameters<T>) => any;
+    /** The main command function that will be executed */
+    execute?: (...args: BaseCommandParameters<T>) => any;
+    /** 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;
+    /** Custom error handler */
+    onError?: (error: Error, ...args: BaseCommandParameters<T>) => any;
+}
+interface CommandInternalRateLimitData {
+    /** Number of times executed */
+    executions: number;
+    /** Timestamp of latest execution */
+    timestamp: number;
+}
+
+declare class BaseCommandBuilder<T extends CommandType, CommandConfig extends BaseCommandOptions<T> & BaseCommandFunctionConfig<T> = BaseCommandOptions<T> & BaseCommandFunctionConfig<T>> implements BaseCommandOptions<T>, BaseCommandFunctionConfig<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);
+    private validateBaseConfig;
+    toConfig(): BaseCommandConfig<T>;
+    setEnabled(enabled: boolean): this;
+    addConditions(...conditions: Array<(...args: BaseCommandParameters<CommandType>) => boolean>): this;
+    setConditions(conditions: Array<(...args: BaseCommandParameters<CommandType>) => boolean>): this;
+    setPermissions(permissions: CommandPermissions): this;
+    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>;
+}
+
+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>;
+interface MongoSchemaEvents {
+    initialized: [];
+    ready: [boolean];
+    error: [Error];
+}
+interface MongoSchemaOptions {
+    connectionIndex?: number;
+}
+declare function createMongoSchema<Definition extends object>(collection: string, definition: SchemaDefinition<Definition>, options?: MongoSchemaOptions): MongoSchemaBuilder<Definition>;
+declare class MongoSchemaBuilder<Definition extends object> {
+    schema: Schema<Definition>;
+    model: Model<Definition>;
+    database: MongoDatabase | null;
+    connectionIndex: number;
+    isReady: boolean;
+    isInitializing: boolean;
+    eventEmitter: EventEmitter<MongoSchemaEvents>;
+    logger: Logger;
+    constructor(collection: string, definition: SchemaDefinition<Definition>, options?: MongoSchemaOptions);
+    private init;
+    extend<Extra extends Record<string, (...args: any) => any>>(extras: Extra & ThisType<MongoSchemaBuilder<Definition>>): MongoSchemaBuilder<Definition> & Extra;
+    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>;
+    createHexId(bytes: number, path: keyof Require_id<Definition>, maxRetries?: number): Promise<string | undefined>;
+    count(filter?: RootFilterQuery<Definition>): 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 {
+        __v?: infer U;
+    } ? T : T & {
+        __v: number;
+    } : never : never)) | undefined>;
+    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>;
+    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>;
+    aggregate<T extends any>(pipeline: PipelineStage[], options?: AggregateOptions): Promise<T[]>;
+}
+
+type _TextInputComponentData = Partial<APITextInputComponent> & _LabelComponentData;
+type _StringSelectComponentData = Partial<APIStringSelectComponent> & _LabelComponentData;
+type _ChannelSelectComponentData = Partial<APIChannelSelectComponent> & _LabelComponentData;
+type _UserSelectComponentData = Partial<APIUserSelectComponent> & _LabelComponentData;
+type _RoleSelectComponentData = Partial<APIRoleSelectComponent> & _LabelComponentData;
+type _MentionableSelectComponentData = Partial<APIMentionableSelectComponent> & _LabelComponentData;
+type _FileUploadComponentData = Partial<APIFileUploadComponent> & _LabelComponentData;
+type BetterTextInputComponent = {
+    textInput: _TextInputComponentData;
+};
+type BetterStringSelectComponent = {
+    stringSelect: _StringSelectComponentData;
+};
+type BetterChannelSelectComponent = {
+    channelSelect: _ChannelSelectComponentData;
+};
+type BetterUserSelectComponent = {
+    userSelect: _UserSelectComponentData;
+};
+type BetterRoleSelectComponent = {
+    roleSelect: _RoleSelectComponentData;
+};
+type BetterMentionableSelectComponent = {
+    mentionableSelect: _MentionableSelectComponentData;
+};
+type BetterFileUploadSelectComponent = {
+    fileUpload: _FileUploadComponentData;
+};
+type BetterModalComponent = BetterTextInputComponent | BetterStringSelectComponent | BetterChannelSelectComponent | BetterUserSelectComponent | BetterRoleSelectComponent | BetterMentionableSelectComponent | BetterFileUploadSelectComponent;
+interface _LabelComponentData {
+    label: string;
+    description?: string;
+}
+interface BetterModalOptions {
+    /** The ID of the modal, if not provided will generate a time-based ID */
+    id?: string;
+    /** The title of the modal */
+    title?: string;
+    /** Max 5 components */
+    components?: BetterModalComponent[];
+    config?: VimcordToolsConfig;
+}
+interface ModalSubmitResult<T extends Record<string, any> = Record<string, any>> {
+    /** Modal fields by custom_id */
+    fields: T;
+    /** Modal fields in the order components were added */
+    values: any[];
+    /** The modal submit interaction for replying */
+    interaction: ModalSubmitInteraction;
+}
+declare class BetterModal {
+    id: string;
+    options: BetterModalOptions;
+    private modal;
+    private components;
+    private config;
+    constructor(options?: BetterModalOptions);
+    private createModalId;
+    private createComponentId;
+    private validateComponentLength;
+    toJSON(): APIModalInteractionResponseCallbackData;
+    build(): ModalBuilder;
+    setTitle(title: string): this;
+    addComponents(...components: BetterModalComponent[]): this;
+    setComponents(...components: BetterModalComponent[]): this;
+    addTextInput(data: _TextInputComponentData): this;
+    addStringSelect(data: _StringSelectComponentData): this;
+    addChannelSelect(data: _ChannelSelectComponentData): this;
+    addUserSelect(data: _UserSelectComponentData): this;
+    addRoleSelect(data: _RoleSelectComponentData): this;
+    addMentionableSelect(data: _MentionableSelectComponentData): this;
+    addFileUpload(data: _FileUploadComponentData): this;
+    /** Show the modal via interaction */
+    show(interaction: Interaction): Promise<void>;
+    /** Waits for the modal to be submitted and returns the component data
+     * @param interaction The interaction used to show the modal
+     * @param options Options */
+    awaitSubmit<T extends Record<string, any> = Record<string, string>>(interaction: Interaction, options?: Omit<AwaitModalSubmitOptions<ModalSubmitInteraction>, "filter">): Promise<ModalSubmitResult<T> | null>;
+    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 PageResolvable = SinglePageResolvable | EmbedResolvable[];
+type Chapter = PageResolvable[];
+interface PageIndex {
+    chapter: number;
+    nested: number;
+}
+interface ChapterData extends Omit<SelectMenuComponentOptionData, "value"> {
+    value?: string;
+}
+interface PaginationEvent {
+    beforeChapterChange: [chapterIndex: number];
+    chapterChange: [option: StringSelectMenuOptionBuilder, page: PageResolvable, index: PageIndex];
+    beforePageChange: [nestedIndex: number];
+    pageChange: [page: PageResolvable, index: PageIndex];
+    first: [page: PageResolvable, index: PageIndex];
+    back: [page: PageResolvable, index: PageIndex];
+    jump: [page: PageResolvable, index: PageIndex];
+    next: [page: PageResolvable, index: PageIndex];
+    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];
+}
+interface PaginatorOptions {
+    /** @default {@link PaginationType.Short} */
+    type?: PaginationType;
+    participants?: UserResolvable$1[];
+    /** Shorthand to create the Paginator with only 1 chapter */
+    pages?: PageResolvable[];
+    /** @default false */
+    useReactions?: boolean;
+    /** @default false */
+    dynamic?: boolean;
+    timeout?: number;
+    /** @default {@link PaginationTimeoutType.ClearComponents} */
+    onTimeout?: PaginationTimeoutType;
+    config?: VimcordToolsConfig;
+}
+interface PaginatorData {
+    message: Message | null;
+    messageActionRows: ActionRowBuilder<StringSelectMenuBuilder | ButtonBuilder>[];
+    messageSendOptions: DynaSendOptions | undefined;
+    extraButtons: {
+        index: number;
+        component: ButtonBuilder;
+    }[];
+    page: {
+        current: PageResolvable | null;
+        index: PageIndex;
+    };
+    navigation: {
+        reactions: {
+            name: string;
+            id: string;
+        }[];
+        isRequired: boolean;
+        isLong: boolean;
+        canJump: boolean;
+    };
+    collectors: {
+        component: InteractionCollector<StringSelectMenuInteraction | ButtonInteraction> | null;
+        reaction: ReactionCollector | null;
+    };
+    components: {
+        chapterSelect: StringSelectMenuBuilder;
+        navigation: Record<keyof VimcordToolsConfig["paginator"]["buttons"], ButtonBuilder>;
+        actionRows: {
+            chapterSelect: ActionRowBuilder<StringSelectMenuBuilder>;
+            navigation: ActionRowBuilder<ButtonBuilder>;
+        };
+    };
+}
+declare enum PaginationType {
+    Short = 0,
+    ShortJump = 1,
+    Long = 2,
+    LongJump = 3
+}
+declare enum PaginationTimeoutType {
+    DisableComponents = 0,
+    ClearComponents = 1,
+    DeleteMessage = 2
+}
+declare class Paginator {
+    chapters: {
+        id: string;
+        pages: Chapter;
+    }[];
+    private options;
+    private config;
+    private data;
+    private events;
+    eventEmitter: EventEmitter<PaginationEvent>;
+    constructor(options?: PaginatorOptions);
+    private build;
+    private buildSendOptions;
+    private handlePostTimeout;
+    private nav_removeFromMessage;
+    private nav_addReactions;
+    private collect_components;
+    private callEventStack;
+    on<T extends keyof PaginationEvent>(event: T, listener: (...args: PaginationEvent[T]) => void, once?: boolean): this;
+    /** Adds a chapter to the paginator.
+     * @param pages The pages for this chapter.
+     * Note: `[Embed1, Embed2]` = 2 Pages. `[[Embed1, Embed2]]` = 1 Page (Group of 2).
+     * @param data Metadata for the chapter select menu. */
+    addChapter(pages: PageResolvable | PageResolvable[], data: ChapterData): this;
+    spliceChapters(index: number, deleteCount: number): this;
+    hydrateChapter(index: number, pages: PageResolvable | PageResolvable[], set?: boolean): this;
+    setPaginationType(type: PaginationType): this;
+    insertButtonAt(index: number, component: ButtonBuilder): this;
+    removeButtonAt(...index: number[]): this;
+    setPage(chapterIndex?: number, nestedIndex?: number): Promise<void>;
+    refresh(): Promise<Message | null>;
+    send(handler: SendHandler, options?: DynaSendOptions): Promise<Message | null>;
+}
+
+declare enum PromptResolveType {
+    DisableComponents = 0,
+    ClearComponents = 1,
+    DeleteOnConfirm = 3,
+    DeleteOnReject = 4
+}
+type ButtonHandler = (interaction: ButtonInteraction) => void | Promise<void>;
+interface CustomButton {
+    builder: ButtonBuilder | ((builder: ButtonBuilder) => ButtonBuilder) | Partial<APIButtonComponent>;
+    handler?: ButtonHandler;
+    /** Position index: 0 = before confirm, 1 = between confirm/reject, 2+ = after reject
+     * @default 2 */
+    index?: number;
+}
+interface PromptOptions {
+    participants?: UserResolvable$1[];
+    content?: string;
+    embed?: EmbedResolvable;
+    container?: ContainerBuilder | BetterContainer;
+    buttons?: {
+        confirm?: ButtonBuilder | ((builder: ButtonBuilder) => ButtonBuilder) | Partial<APIButtonComponent>;
+        reject?: ButtonBuilder | ((builder: ButtonBuilder) => ButtonBuilder) | Partial<APIButtonComponent>;
+    };
+    customButtons?: Record<string, CustomButton>;
+    /** @default [PromptResolveType.DeleteOnConfirm, PromptResolveType.DeleteOnReject] */
+    onResolve?: PromptResolveType[];
+    timeout?: number;
+    config?: VimcordToolsConfig;
+}
+interface PromptResult {
+    message: Message | null;
+    confirmed: boolean | null;
+    customId: string | null;
+    timedOut: boolean;
+}
+declare class Prompt {
+    readonly participants: UserResolvable$1[];
+    readonly content?: string;
+    readonly embed: EmbedResolvable;
+    readonly container?: ContainerBuilder | BetterContainer;
+    readonly buttons: {
+        confirm: ButtonBuilder;
+        reject: ButtonBuilder;
+    };
+    readonly customButtons: Map<string, {
+        button: ButtonBuilder;
+        handler?: ButtonHandler;
+        index: number;
+    }>;
+    readonly onResolve: PromptResolveType[];
+    readonly timeout: number;
+    readonly config: VimcordToolsConfig;
+    private message;
+    constructor(options?: PromptOptions);
+    private createDefaultForm;
+    private createButtons;
+    private createCustomButtons;
+    private buildButton;
+    private buildActionRow;
+    private buildSendOptions;
+    private isParticipant;
+    private handleResolve;
+    send(handler: SendHandler, options?: DynaSendOptions): Promise<Message | null>;
+    awaitResponse(): Promise<PromptResult>;
+}
+/** Create and send a prompt, awaiting its response
+ * @param handler - The send handler
+ * @param options - Prompt options
+ * @param sendOptions - Additional send options */
+declare function prompt(handler: SendHandler, options?: PromptOptions, sendOptions?: DynaSendOptions): Promise<PromptResult>;
+
+type FetchedChannel<T> = T extends ChannelType.DM ? PartialGroupDMChannel | DMChannel | PartialDMChannel : T extends ChannelType.GuildText ? GuildBasedChannel & TextBasedChannel : T extends ChannelType.PublicThread | ChannelType.PrivateThread | ChannelType.AnnouncementThread ? AnyThreadChannel : T extends ChannelType.GuildVoice ? VoiceBasedChannel : T extends ChannelType.GuildCategory ? CategoryChannel : GuildBasedChannel;
+type FetchedMessageMention<T extends MentionType, InGuild extends boolean> = T extends "user" ? User : T extends "member" ? GuildMember : T extends "channel" ? InGuild extends true ? GuildBasedChannel : Channel : Role;
+type MentionType = "user" | "member" | "channel" | "role";
+interface GetMessageMentionOptions {
+    cleanContent?: string;
+    /** Return the ID instead of the object. */
+    parse?: boolean;
+}
+/** Returns the string if it's populated, or "0" otherwise.
+ *
+ * Useful for fetching where the provided ID may or may not exist.
+ * @param str The string to check. */
+declare function __zero(str?: string | null): string;
+/** Check if the given string is a mention or a snowflake.
+ *
+ * Looks for formats like `<@123456789>`, or a numeric string with at least 6 digits.
+ * @param str The string to check. */
+declare function isMentionOrSnowflake(str: string | undefined): boolean;
+/** Remove mention syntax from a string.
+ * @param str The string to clean. */
+declare function cleanMention(str: string | undefined): string | undefined;
+/** Get a mention or snowflake argument of a specified type from a message.
+ * @param message - The message to parse.
+ * @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. */
+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.
+ * @param options Optional options that aren't really optional. */
+declare function getFirstMentionId(options: {
+    message?: Message;
+    content?: string;
+    type: MentionType;
+}): string;
+/** Fetch a user from the client, checking the cache first.
+ * @param client - The client to fetch the user from.
+ * @param userId - The ID of the user to fetch. */
+declare function fetchUser(client: Client<true>, userId: string | undefined | null): Promise<User | null>;
+/** Fetch a guild from the client, checking the cache first.
+ * @param client - The client to fetch the guild from.
+ * @param guildId - The ID of the guild to fetch. */
+declare function fetchGuild(client: Client<true>, guildId: string | undefined | null): Promise<Guild | null>;
+/** Fetch a member from a guild, checking the cache first.
+ * @param guild - The guild to fetch the member from.
+ * @param memberId - The ID of the member to fetch. */
+declare function fetchMember(guild: Guild, memberId: string | undefined | null): Promise<GuildMember | null>;
+/** Fetch a channel from a guild, checking the cache first.
+ *
+ * ***NOTE:*** If the channel type does not match the provided type or the channel is null, null is returned.
+ * @param guild - The guild to fetch the channel from.
+ * @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>;
+
+interface VimcordCLIOptions {
+    prefix: string;
+}
+declare class VimcordCLI {
+    rl: Interface;
+    options: VimcordCLIOptions;
+    commands: Map<string, {
+        description: string;
+        fn: (args: string[], content: string) => void;
+    }>;
+    logger: Logger;
+    constructor(options: VimcordCLIOptions);
+    private parseLine;
+    getClientInstance(line: string): Vimcord<boolean> | undefined;
+    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;
+
+declare function retryExponentialBackoff<T>(fn: (attempt: number) => Promise<T>, maxRetries?: number, retryDelay?: number): Promise<T>;
+
+type VimcordConfigOptions = PartialDeep<VimcordConfig>;
+declare function useClient(index?: number): Vimcord<boolean> | undefined;
+declare function useReadyClient(index?: number): Promise<Vimcord<true> | undefined>;
+/** Automatically bundles **🚀 {@link VimcordCLI}** with client creation */
+declare function createClient(options: ClientOptions, features?: VimcordFeatures, config?: VimcordConfigOptions): Vimcord<boolean>;
+declare function getClientInstances(): Vimcord<boolean>[];
+
+declare function getProcessDir(): string;
+declare function importModulesFromDir<T extends any>(dir: string, fnPrefix?: string): Promise<{
+    module: T;
+    path: string;
+}[]>;
+declare function getCallerFileName(): string | undefined;
+
+declare function formatThousands(num: number, sep?: string): string;
+
+declare function pickRandom<T extends any[]>(arr: T, options?: {
+    notEqualTo?: any;
+    maxRerollAttempts?: number;
+    clone?: boolean;
+}): T[number];
+
+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;
+
+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 };